[Cao Peng] iP

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.
 
@@ -12,7 +12,7 @@ Prerequisites: JDK 11, update Intellij to the most recent version.
    1. Select the project directory, and click `OK`.
    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).
-1. After that, locate the `src/main/java/Duke.java` file, right-click it, and choose `Run Duke.main()`. If the setup is correct, you should see something like the below:
+1. After that, locate the `src/main/java/duke.Duke.java` file, right-click it, and choose `Run duke.Duke.main()`. If the setup is correct, you should see something like the below:
    ```
    Hello from
     ____        _        

data/duke.txt

@@ -0,0 +1 @@
+[T][X] homework1

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,52 @@
+package duke;
+
+import duke.command.Command;
+import duke.exception.DukeException;
+
+import java.util.ArrayList;
+
+/**
+ * the agent program to run duke.Duke
+ */
+public class Duke {
+    private static final String FILE_PATH = "./data/duke.txt";
+    private Ui ui;
+    private TaskList tasks;
+    private Storage storage;
+    private Parser parser;
+
+    public Duke() {
+        this.ui = new Ui();
+        this.parser = new Parser();
+        this.storage = new Storage(FILE_PATH);
+
+        try {
+            this.tasks = new TaskList(storage.load());
+        } catch (DukeException e) {
+            ui.printMsg(e.getMessage());
+            this.tasks = new TaskList(new ArrayList<>());
+        }
+    }
+
+    public static void main(String[] args) {
+        new Duke().run();
+    }
+
+    public void run() {
+        ui.printGreetingMsg();
+
+        boolean isExit = false;
+        while(!isExit) {
+            String fullCommand = ui.readCommand();
+            ui.printLine();
+            try {
+                Command command = parser.parseCommand(fullCommand);
+                command.execute(tasks, ui, storage);
+                isExit = command.isExit();
+            } catch (DukeException e) {
+                ui.printMsg(e.getMessage());
+            }
+            ui.printLine();
+        }
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,101 @@
+package duke;
+
+import duke.command.*;
+import duke.exception.DukeException;
+import duke.exception.EmptyTodoDescriptionException;
+import duke.exception.UnknownCommandException;
+import duke.task.Deadline;
+import duke.task.Event;
+import duke.task.Task;
+import duke.task.ToDo;
+
+import java.time.LocalDate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * deals with parsing the user command
+ */
+public class Parser {
+
+    /**
+     * @param fullCommand the user command
+     * @return a duke.command.Command object which encapsulates the information of a parsed user command
+     * @throws DukeException exception when there is an parsing error
+     */
+    public Command parseCommand(String fullCommand) throws DukeException {
+        if (fullCommand.equals("bye")) {
+            return new ExitCommand();
+        } else if (fullCommand.equals("list")) {
+            return new ListCommand();
+        } else {
+            String[] parsedCommand = fullCommand.split(" ");
+
+            try {
+                switch (parsedCommand[0]) {
+                    case "done", "delete":
+                        int taskId = Integer.parseInt(parsedCommand[1]) - 1;
+                        if (parsedCommand[0].equals("done")) {
+                            return new DoneCommand(fullCommand, taskId);
+                        } else {
+                            return new DeleteCommand(fullCommand, taskId);
+                        }
+                    case "find":
+                        return new FindCommand(fullCommand, fullCommand.replaceFirst("find ", ""));
+                    case "todo", "deadline", "event":
+                        Task task = parseTask(parsedCommand[0], fullCommand.replaceFirst(parsedCommand[0] + " ", ""));
+                        return new AddCommand(fullCommand, task);
+                    default:
+                        throw new UnknownCommandException();
+                }
+            } catch (DukeException e) {
+                throw e;
+            } catch (Exception e) {
+                throw new DukeException("duke.command.Command parsing error!");
+            }
+        }
+    }
+
+    /**
+     * @param taskType the type of the task
+     * @param taskStr part of the user command which represents a task
+     * @return a duke.task.Task object in the user command
+     * @throws DukeException exception when there is a task parsing error
+     */
+    private Task parseTask(String taskType, String taskStr) throws DukeException {
+        String pattern;
+        Pattern r;
+        Matcher m;
+
+        if (taskType.equals("todo") && taskStr.isEmpty()) {
+            throw new EmptyTodoDescriptionException();
+        }
+
+        try {
+            switch (taskType) {
+                case "todo":
+                    return new ToDo(taskStr);
+                case "deadline":
+                    pattern = "(.*) /by (.*)$";
+                    r = Pattern.compile(pattern);
+                    m = r.matcher(taskStr);
+                    if (m.find()) {
+                        return new Deadline(m.group(1), LocalDate.parse(m.group(2)));
+                    }
+                case "event":
+                    pattern = "(.*) /at (.*)$";
+                    r = Pattern.compile(pattern);
+                    m = r.matcher(taskStr);
+                    if (m.find()) {
+                        return new Event(m.group(1), LocalDate.parse(m.group(2)));
+                    }
+                default:
+                    throw new UnknownCommandException();
+            }
+        } catch (DukeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new DukeException("duke.task.Task parsing error!");
+        }
+    }
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,136 @@
+package duke;
+
+import duke.exception.DukeException;
+import duke.task.Deadline;
+import duke.task.Event;
+import duke.task.Task;
+import duke.task.ToDo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Deals with loading tasks from the file and saving tasks in the file.
+ */
+public class Storage {
+    private String filePath;
+    private String dirPath;
+
+    /**
+     * @param filePath The file path of the file which is used to store task list.
+     */
+    public Storage(String filePath) {
+        this.filePath = filePath;
+        parseFilePath();
+    }
+
+    /**
+     * Extracts directory path from the file path.
+     */
+    public void parseFilePath() {
+        String pattern = "(.*)/(.*)$";
+        Pattern r = Pattern.compile(pattern);
+        Matcher m = r.matcher(filePath);
+        if (m.find()) {
+            this.dirPath = m.group(1);
+        }
+    }
+
+    /**
+     * Loads task list from the file and returns the task list.
+     * @return The task list which is loaded from the file.
+     * @throws DukeException Exception if there is error when loading from the file.
+     */
+    public ArrayList<Task> load() throws DukeException {
+        // create the folder called data if not found
+        ArrayList<Task> tasks = new ArrayList<>();
+
+        File dir = new File(dirPath);
+        if (!dir.exists() || !dir.isDirectory()) {
+            dir.mkdir();
+        }
+
+        File file = new File(filePath);
+        try {
+            Scanner sc = new Scanner(file);
+            while (sc.hasNextLine()) {
+                tasks.add(parseTask(sc.nextLine()));
+            }
+            sc.close();
+            return tasks;
+        } catch (FileNotFoundException e) {
+            throw new DukeException("Cannot load from file!");
+        }
+    }
+
+    /**
+     * Parses the task string to a duke.task.Task object.
+     * @param str The string which represents a single task.
+     * @return A duke.task.Task object which represents a task as the string.
+     * @throws DukeException Exception if there is error when parsing the task string.
+     */
+    public Task parseTask(String str) throws DukeException {
+        try {
+            char typeLabel = str.charAt(1);
+            boolean isDone = str.charAt(4) == 'X';
+            String body = str.substring(7);
+            String pattern;
+            Pattern r;
+            Matcher m;
+            switch (typeLabel) {
+                case 'T':
+                    return new ToDo(body, isDone);
+                case 'D':
+                    pattern = "(.*) \\(by: (.*)\\)";
+                    r = Pattern.compile(pattern);
+                    m = r.matcher(body);
+                    if (m.find()) {
+                        LocalDate deadline = LocalDate.parse(m.group(2), DateTimeFormatter.ofPattern("MMM dd yyyy"));
+                        return new Deadline(m.group(1), isDone, deadline);
+                    }
+                case 'E':
+                    pattern = "(.*) \\(at: (.*)\\)";
+                    r = Pattern.compile(pattern);
+                    m = r.matcher(body);
+                    if (m.find()) {
+                        LocalDate time = LocalDate.parse(m.group(2), DateTimeFormatter.ofPattern("MMM dd yyyy"));
+                        return new Event(m.group(1), isDone, time);
+                    }
+                default:
+                    throw new Exception();
+            }
+        } catch (Exception e) {
+            throw new DukeException("error occurs and loading from file is suspended!");
+        }
+    }
+
+    /**
+     * Saves the task list to the file.
+     * @param tasks The TaskList object whose string representation will be saved to the file.
+     * @throws DukeException Exception when there is an error when saving task list to the file.
+     */
+    public void save(TaskList tasks) throws DukeException {
+        // make the data directory if not found
+        File dir = new File(dirPath);
+        if (!dir.exists() || !dir.isDirectory()) {
+            dir.mkdir();
+        }
+
+        try {
+            FileWriter writer = new FileWriter(filePath);
+            writer.write(tasks.toString());
+            writer.flush();
+            writer.close();
+        } catch (IOException e) {
+            throw new DukeException("Save to file error!");
+        }
+    }
+}