diff --git a/.gitignore b/.gitignore index 2873e189e..fed856c0f 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,7 @@ bin/ /text-ui-test/ACTUAL.TXT text-ui-test/EXPECTED-UNIX.TXT +src/main/java/Duke.class +src/main/java/Task.class +src/main/java/TaskManager.class +*.class diff --git a/IP.jar b/IP.jar new file mode 100644 index 000000000..89f980a2d Binary files /dev/null and b/IP.jar differ diff --git a/docs/README.md b/docs/README.md index 8077118eb..e659f5aea 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,29 +1,138 @@ -# User Guide +User Guide +Features +Adding a Todo Task +Add a new Todo task to the list of tasks. -## Features +Adding a Deadline Task +Add a new Deadline task to the list of tasks. -### Feature-ABC +Adding an Event Task +Add a new Event task to the list of tasks. -Description of the feature. +Listing all Tasks +List all the tasks in the TaskManager. -### Feature-XYZ +Marking a Task as Done +Mark a task in the TaskManager as done. -Description of the feature. +Unmarking a Task +Unmark a task in the TaskManager. -## Usage +Deleting a Task +Delete a task from the TaskManager. -### `Keyword` - Describe action +Clearing all Tasks +Clear all the tasks from the TaskManager. -Describe the action and its outcome. +Finding Tasks by Keyword +Find tasks in the TaskManager by a keyword. -Example of usage: +Usage +todo - Add a Todo task +Add a new Todo task to the list of tasks. -`keyword (optional arguments)` +Example of usage: + +todo read book + +Expected outcome: + +Roger. The following todo has been added: +[T][ ] read book +You now have 1 item in the list + +deadline - Add a Deadline task +Add a new Deadline task to the list of tasks. + +Example of usage: + +deadline return book /by Sunday + +Expected outcome: + +Roger. The following deadline has been added: +[D][ ] return book (by: Sunday) +You now have 1 item in the list + +event - Add an Event task +Add a new Event task to the list of tasks. + +Example of usage: + +event project meeting /at Monday 2pm + +Expected outcome: + +Roger. The following event has been added: +[E][ ] project meeting (at: Monday 2pm) +You now have 1 item in the list + +list - List all Tasks +List all the tasks in the TaskManager. + +Example of usage: + +list Expected outcome: -Description of the outcome. +Here are the tasks in your list: +1.[T][ ] read book +2.[D][ ] return book (by: Sunday) +3.[E][ ] project meeting (at: Monday 2pm) + +mark - Mark a Task as Done +Mark a task in the TaskManager as done. + +Example of usage: + +mark 2 + +Expected outcome: + +Nice! I've marked this task as done: +[D][X] return book (by: Sunday) + + +unmark - Unmark a Task +Unmark a task in the TaskManager. + +Example of usage: + +unmark 2 + +Expected outcome: + +Nice! I've unmarked this task: +[D][ ] return book (by: Sunday) +delete - Delete a Task +Delete a task from the TaskManager. + +Example of usage: + +delete 2 + +Expected outcome: + +Noted. I've removed this task: +[D][ ] return book (by: Sunday) + +Example of usage: + +clear + +Expected outcome: + +All data deleted. You have no items in your list. + +find - Find Tasks by Keyword +Find tasks in the TaskManager by a keyword. + +Example of usage: + +find book + +Expected outcome: -``` -expected output -``` +Here are the matching tasks in your list: +1.[T][ ] read book \ No newline at end of file diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java index 5d313334c..b3bff38c4 100644 --- a/src/main/java/Duke.java +++ b/src/main/java/Duke.java @@ -1,10 +1,28 @@ +import java.util.Scanner; +import java.io.IOException; + +import duke.Parser; +import duke.Storage; +import duke.TaskManager; +import duke.Ui; + +/** + * Duke main class. This is the entry point for the Duke program. + */ public class Duke { - public static void main(String[] args) { - String logo = " ____ _ \n" - + "| _ \\ _ _| | _____ \n" - + "| | | | | | | |/ / _ \\\n" - + "| |_| | |_| | < __/\n" - + "|____/ \\__,_|_|\\_\\___|\n"; - System.out.println("Hello from\n" + logo); + public static void main(String[] args) throws IOException { + Ui ui = new Ui(); + ui.printGreeting(); + Scanner scanObj = new Scanner(System.in); + TaskManager listOfItems = new TaskManager(); + listOfItems = Storage.loadFile(listOfItems); + String userCmd = scanObj.nextLine(); + while (!userCmd.equals("bye")) { + Parser.handleCmd(userCmd, listOfItems, ui); + userCmd = scanObj.nextLine(); + } + scanObj.close(); + ui.printGoodbye(); } + } diff --git a/src/main/java/duke/Deadline.java b/src/main/java/duke/Deadline.java new file mode 100644 index 000000000..70287625e --- /dev/null +++ b/src/main/java/duke/Deadline.java @@ -0,0 +1,45 @@ +package duke; + +/** + * Represents a Deadline task with a specific due date. + * Inherits from the Task class. + */ +public class Deadline extends Task { + protected String by; + + /** + * Constructor for the Deadline class. + * + * @param name the name of the deadline task + * @param isDone whether the task is marked as done or not + * @param by the due date of the task + */ + public Deadline(String name, boolean isDone, String by) { + super(name, isDone); + this.by = by; + } + + /** + * Overrides the toString method to display the task's details as a string. + * + * @return a formatted string representation of the task's details + */ + public String toString() { + if (this.getIsDone() == true) { + return " [D][X] " + this.getName() + " (by: " + this.by + ")"; + } + return " [D][ ] " + this.getName() + " (by: " + this.by + ")"; + } + + /** + * Overrides the print method to print the task details in a specific format. + */ + public void print() { + if (this.isIsDone() == false) { + System.out.println("." + this.toString()); + } else { + System.out.println("." + this.toString()); + } + } + +} diff --git a/src/main/java/duke/Event.java b/src/main/java/duke/Event.java new file mode 100644 index 000000000..345f49a1d --- /dev/null +++ b/src/main/java/duke/Event.java @@ -0,0 +1,53 @@ +package duke; + +/** + * Event class represents an event task with a start time and a finish time. + * It extends the Task class and adds the startTime and finishTime attributes. + */ +public class Event extends Task { + protected String startTime; + protected String finishTime; + + /** + * Constructs an Event object with a name, completion status, start time, and + * finish time. + * + * @param name the name of the event task + * @param isDone the completion status of the event task + * @param startTime the start time of the event task + * @param finishTime the finish time of the event task + */ + public Event(String name, boolean isDone, String startTime, String finishTime) { + super(name, isDone); + this.startTime = startTime; + this.finishTime = finishTime; + } + + /** + * Returns a string representation of the event task with its completion status, + * name, start time, and finish time. + * If the task is completed, the completion status is marked with an 'X', + * otherwise it is marked with a space. + * + * @return a string representation of the event task + */ + public String toString() { + if (this.getIsDone() == true) { + return " [E][X] " + this.getName() + " (from: " + this.startTime + + " to: " + this.finishTime + ")"; + } + return " [E][ ] " + this.getName() + " (from: " + this.startTime + + " to: " + this.finishTime + ")"; + } + + /** + * Prints the string representation of the event task with a dot prefix. + */ + public void print() { + if (this.isIsDone() == false) { + System.out.println("." + this.toString()); + } else { + System.out.println("." + this.toString()); + } + } +} diff --git a/src/main/java/duke/Parser.java b/src/main/java/duke/Parser.java new file mode 100644 index 000000000..8993f5117 --- /dev/null +++ b/src/main/java/duke/Parser.java @@ -0,0 +1,161 @@ +package duke; + +import java.io.IOException; + +/** + * The Parser class is responsible for parsing the user's input command and + * executing the corresponding actions. + */ +public class Parser { + + /** + * Parses the user's input command and executes the corresponding actions. + * + * @param userCmd the user's input command + * @param listOfItems the TaskManager that stores the user's tasks + * @param ui the Ui object that handles the program's output + * @throws IOException if an I/O error occurs + */ + public static void handleCmd(String userCmd, TaskManager listOfItems, Ui ui) throws IOException { + switch (firstWord(userCmd)) { + case "todo": + executeAddTodo(userCmd, listOfItems, ui); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "deadline": + executeAddDeadline(userCmd, listOfItems, ui); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "event": + executeAddEvent(userCmd, listOfItems, ui); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "list": + listOfItems.listTask(); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "mark": + String markId[] = userCmd.split(" "); + listOfItems.markTask(Integer.parseInt(markId[1]) - 1); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "unmark": + String unmarkId[] = userCmd.split(" "); + listOfItems.unmarkTask(Integer.parseInt(unmarkId[1]) - 1); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "delete": + String deleteId[] = userCmd.split(" "); + listOfItems.deleteTask(Integer.parseInt(deleteId[1]) - 1); + ui.printHorizontalLine(); + Storage.saveFile(listOfItems); + break; + case "clear": + listOfItems.clearData(); + Storage.saveFile(listOfItems); + ui.printHorizontalLine(); + break; + case "find": + listOfItems.findItem(userCmd.substring(5, userCmd.length())); + ui.printHorizontalLine(); + break; + default: + ui.printfalseInput(); + ui.printHorizontalLine(); + } + } + + /** + * Returns the first word of a given string. + * + * @param s the string + * @return the first word of the string + */ + public static String firstWord(String s) { + String a[] = s.split(" "); + return a[0]; + } + + /** + * Executes the "todo" command by adding a new Todo task to the TaskManager. + * + * @param s the user's input command + * @param listOfItems the TaskManager that stores the user's tasks + * @param ui the Ui object that handles the program's output + */ + public static void executeAddTodo(String s, TaskManager listOfItems, Ui ui) { + try { + s = s.substring("todo ".length(), s.length()); + listOfItems.addTask(s, false); + System.out.println("Roger. The following todo has been added:"); + System.out.println("[T][ ] " + s); + System.out.println("You now have " + listOfItems.getSize() + " item in the list"); + } catch (StringIndexOutOfBoundsException e) { + System.out.println("Missing todo item. Please read instructions again"); + ui.printInstructions(); + } + } + + /** + * Adds a new Deadline task to the list of tasks. + * + * @param s The string representation of the task to be added. + * @param listOfItems The TaskManager object that holds the list of tasks. + * @param ui The UI object that interacts with the user. + */ + public static void executeAddDeadline(String s, TaskManager listOfItems, Ui ui) { + try { + s = s.substring("deadline ".length(), s.length()); + String[] cmd = s.split(" /by "); + if (cmd.length > 2) { + System.out.println("Extra deadline found! Please try again!"); + ui.printInstructions(); + return; + } + listOfItems.addDeadline(cmd[0], cmd[1], false); + System.out.println("Roger. The following deadline has been added:"); + System.out.println("[D][ ] " + cmd[0] + " (by: " + cmd[1] + ")"); + System.out.println("You now have " + listOfItems.getSize() + " item in the list"); + } catch (StringIndexOutOfBoundsException e) { + System.out.println("Your task name is missing please try again!"); + ui.printInstructions(); + } catch (ArrayIndexOutOfBoundsException e) { + System.out.println("Your deadline is missing please try again!"); + ui.printInstructions(); + } + + } + + /** + * Adds a new Event task to the list of tasks. + * + * @param s The string representation of the task to be added. + * @param listOfItems The TaskManager object that holds the list of tasks. + * @param ui The UI object that interacts with the user. + */ + public static void executeAddEvent(String s, TaskManager listOfItems, Ui ui) { + try { + s = s.substring("event ".length(), s.length()); + String[] cmd = s.split(" /from "); + String startTime = cmd[1].split(" /to ")[0]; + String endTime = cmd[1].split(" /to ")[1]; + listOfItems.addEvent(cmd[0], startTime, endTime, false); + System.out.println("Roger. The following event has been added:"); + System.out.println("[E][ ] " + cmd[0] + " (from: " + startTime + " to: " + endTime + ")"); + System.out.println("You now have " + listOfItems.getSize() + " item in the list"); + } catch (StringIndexOutOfBoundsException e) { + System.out.println("Your task name is missing please try again!"); + ui.printInstructions(); + } catch (ArrayIndexOutOfBoundsException e) { + System.out.println("Something is wrong with your event's start time or finish time please try again!"); + ui.printInstructions(); + } + } + +} diff --git a/src/main/java/duke/Storage.java b/src/main/java/duke/Storage.java new file mode 100644 index 000000000..b520f30a8 --- /dev/null +++ b/src/main/java/duke/Storage.java @@ -0,0 +1,115 @@ +package duke; + +import java.util.Scanner; +import java.io.IOException; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileWriter; + +/** + * Storage class deals with saving and loading TaskManager class. + */ +public class Storage extends TaskManager { + + /** + * Loads data from a file into the given TaskManager object. + * + * @param listOfItems The TaskManager object to load the data into. + * @return The TaskManager object with the loaded data. + * @throws FileNotFoundException If the file to load from is not found. + */ + public static TaskManager loadFile(TaskManager listOfItems) throws FileNotFoundException { + String filePath = "C:/repos/IP/src/main/java/duke/load.txt"; + File f = new File(filePath); + if (!f.exists()) { + throw new FileNotFoundException(); + } + Scanner s = new Scanner(f); + while (s.hasNext()) { + String l = s.nextLine(); + if (l.startsWith(" [T]")) { + loadTodo(listOfItems, l); + } else if (l.startsWith(" [D]")) { + loadDeadline(listOfItems, l); + } else if (l.startsWith(" [E]")) { + loadEvent(listOfItems, l); + } + } + s.close(); + return listOfItems; + } + + /** + * Loads a Todo item from a string and adds it to the given TaskManager object. + * + * @param listOfItems The TaskManager object to add the Todo item to. + * @param l he string containing the Todo item details. + */ + public static void loadTodo(TaskManager listOfItems, String l) { + String name = l.substring(7).trim(); + if (l.contains("[ ]")) { + listOfItems.addTask(name, false); + } else { + listOfItems.addTask(name, true); + } + } + + /** + * Loads an Event item from a string and adds it to the given TaskManager + * object. + * + * @param listOfItems The TaskManager object to add the Event item to. + * @param l The string containing the Event item details. + */ + public static void loadEvent(TaskManager listOfItems, String l) { + int fromIndex = l.indexOf("(from: "); + int toIndex = l.indexOf(" to: ", fromIndex); + String name = l.substring(8, fromIndex).trim(); + String startTime = l.substring(fromIndex + 7, toIndex); + String finishTime = l.substring(toIndex + 5, l.length() - 1); + if (l.contains("[ ]")) { + listOfItems.addEvent(name, startTime, finishTime, false); + } else { + listOfItems.addEvent(name, startTime, finishTime, true); + } + } + + /** + * Loads a Deadline item from a string and adds it to the given TaskManager + * object. + * + * @param listOfItems The TaskManager object to add the Deadline item to. + * @param l The string containing the Deadline item details. + */ + public static void loadDeadline(TaskManager listOfItems, String l) { + int byIndex = l.indexOf("(by: "); + String name = l.substring(8, byIndex - 1); + int endIndex = l.indexOf(")"); + String deadline = l.substring(byIndex + 5, endIndex); + if (l.contains("[ ]")) { + listOfItems.addDeadline(name, deadline, false); + } else { + listOfItems.addDeadline(name, deadline, true); + } + } + + /** + * Save the TaskManager object into the harddrive. + * + * @param listOfItems The TaskManager object + * @throws IOException If there is something wrong with saving the file + */ + public static void saveFile(TaskManager listOfItems) throws IOException { + String filePath = "C:/repos/IP/src/main/java/duke/load.txt"; + FileWriter fw = new FileWriter(filePath); + for (int i = 0; i < listOfItems.getSize(); i++) { + try { + fw.write(listOfItems.getId(i).toString() + System.lineSeparator()); + } catch (IOException e) { + System.out.println("Something went wrong: " + e.getMessage()); + } + } + fw.close(); + } + +} diff --git a/src/main/java/duke/Task.java b/src/main/java/duke/Task.java new file mode 100644 index 000000000..a3ff85b51 --- /dev/null +++ b/src/main/java/duke/Task.java @@ -0,0 +1,130 @@ +package duke; + +/* +The Task class represents a task with a name, a completion status, and a task type. +*/ +public class Task { + private String name; + private boolean isDone; + private char taskType; + + /** + * Returns the completion status of the task. + * + * @return a boolean representing the completion status of the task. + */ + public boolean isIsDone() { + return this.isDone; + } + + /** + * Returns the type of the task. + * + * @return a char representing the type of the task. + */ + public char getTaskType() { + return this.taskType; + } + + /* + * Sets the type of the task. + * + * @param taskType a char representing the type of the task. + */ + public void setTaskType(char taskType) { + this.taskType = taskType; + } + + /* + * Creates a new task with a given name and completion status. + * + * @param name a String representing the name of the task. + * + * @param isDone a boolean representing the completion status of the task. + */ + public Task(String name, boolean isDone) { + this.name = name; + this.isDone = isDone; + } + + /** + * Returns the name of the task. + * + * @return a String representing the name of the task. + */ + public String getName() { + return this.name; + } + + /** + * Sets the name of the task. + * + * @param name a String representing the name of the task. + */ + public void setName(String name) { + this.name = name; + } + + /** + * Returns the completion status of the task. + * + * @return a boolean representing the completion status of the task. + */ + public boolean isDone() { + return this.isDone; + } + + /** + * Returns the completion status of the task. + * + * @return a boolean representing the completion status of the task. + */ + public boolean getIsDone() { + return this.isDone; + } + + /** + * Sets the completion status of the task. + * + * @param isDone a boolean representing the completion status of the task. + */ + public void setIsDone(boolean isDone) { + this.isDone = isDone; + } + + /** + * Returns a String representation of the task. + * + * @return a String representing the task. + */ + public String toString() { + if (this.isDone == true) { + return " [T][X] " + this.name; + } + return " [T][ ] " + this.name; + } + + /** + * Prints the task to the console. + */ + public void print() { + if (this.isDone == false) { + System.out.println("." + this.toString()); + } else { + System.out.println("." + this.toString()); + } + } + + /** + * Searches the name of the task for a given String. + * + * @param s a String representing the search query. + * + * @return a boolean indicating whether the search query was found in the name + * of the task. + */ + public boolean find(String s) { + return this.name.contains(s); + } + +} diff --git a/src/main/java/duke/TaskManager.java b/src/main/java/duke/TaskManager.java new file mode 100644 index 000000000..e58fefbde --- /dev/null +++ b/src/main/java/duke/TaskManager.java @@ -0,0 +1,144 @@ +package duke; + +import java.util.*; + +/** + * This class represents a task manager that stores and manages tasks. + */ +public class TaskManager { + private ArrayList tasks = new ArrayList<>(); + + /** + * Finds a task in the list of tasks that contains the given string. + * If a matching task is found, its details are printed. + * If no matching task is found, a message is printed. + * + * @param s The string to search for in the task names. + */ + public void findItem(String s) { + boolean found = false; + if (tasks.size() == 0) { + System.out.println("The list is currently empty!"); + return; + } + for (int i = 0; i < tasks.size(); i++) { + if (tasks.get(i).find(s)) { + System.out.println("Item found: " + (i + 1) + "." + tasks.get(i).toString()); + found = true; + } + } + if (found == false) { + System.out.println("Sorry there is no match for your search !"); + } + } + + /** + * Adds a task with the given name and completion status to the list of tasks. + * + * @param name The name of the task. + * @param isDone The completion status of the task. + */ + public void addTask(String name, boolean isDone) { + tasks.add(new Task(name, isDone)); + } + + /** + * Adds a deadline with the given name, completion status, and deadline string + * to the list of tasks. + * + * @param name The name of the deadline. + * @param deadline The deadline string. + * @param isDone The completion status of the deadline. + */ + public void addDeadline(String name, String deadline, boolean isDone) { + tasks.add(new Deadline(name, isDone, deadline)); + } + + /** + * Adds an event with the given name, start time, finish time, and completion + * status to the list of tasks. + * + * @param eventName The name of the event. + * @param startTime The start time string. + * @param finishTime The finish time string. + * @param isDone The completion status of the event. + */ + public void addEvent(String eventName, String startTime, String finishTime, boolean isDone) { + tasks.add(new Event(eventName, isDone, startTime, finishTime)); + } + + /** + * Marks the task with the given ID as done. + * + * @param id The ID of the task to mark as done. + */ + public void markTask(int id) { + tasks.get(id).setIsDone(true); + System.out.println("This item has been marked as done!"); + System.out.println("[X] " + tasks.get(id).getName()); + } + + /** + * Unmarks the task with the given ID as done. + * + * @param id The ID of the task to unmark as done. + */ + public void unmarkTask(int id) { + tasks.get(id).setIsDone(false); + System.out.println("The item has been marked as NOT done!"); + System.out.println("[ ] " + tasks.get(id).getName()); + } + + /** + * Lists all the tasks in the task manager. + */ + public void listTask() { + if (tasks.size() == 0) { + System.out.println("The list is currently empty!"); + return; + } + for (int i = 0; i < tasks.size(); i++) { + System.out.print(i + 1); + tasks.get(i).print(); + } + } + + /** + * Deletes a task at the specified index. + * + * @param id The index of the task to be deleted. + */ + public void deleteTask(int id) { + System.out.println("This item has been deleted!"); + System.out.println("[ ] " + tasks.get(id).getName()); + tasks.remove(id); + } + + /** + * Gets the size of the task list. + * + * @return The size of the task list. + */ + public int getSize() { + return tasks.size(); + } + + /** + * Clears all tasks from the task list. + */ + public void clearData() { + tasks.clear(); + System.out.println("Your list has been cleared !"); + } + + /** + * Gets the task at the specified index. + * + * @param id The index of the task to be retrieved. + * @return The task at the specified index. + */ + public Task getId(int id) { + return tasks.get(id); + } + +} diff --git a/src/main/java/duke/Ui.java b/src/main/java/duke/Ui.java new file mode 100644 index 000000000..f3a5a4f23 --- /dev/null +++ b/src/main/java/duke/Ui.java @@ -0,0 +1,70 @@ +package duke; + +/** + * This class manages the UI for Duke + */ +public class Ui { + /** + * Print the Input guidelines for the reader such that Duke understands the + * Input + */ + public void printInstructions() { + System.out.println("LIST OF ALL COMMANDS:"); + System.out.println("todo + \"task name\" to add a task"); + System.out.println("deadline + \"task name\" + /by \"task deadline\" to add a task with a deadline"); + System.out.println( + "event + \"event name\" + /from \"event start time\" + /to \"event finish time\" to add an event with a stant and finish time"); + System.out.println("list to list all events and tasks available"); + System.out.println("mark + \"task number\" to mark an item"); + System.out.println("unmark + \"task number\" to unmark an item"); + System.out.println("delete + \"task number\" to remove an item"); + System.out.println("clear to clear all data in the hard drive"); + System.out.println("find + \"phrase\" to find an item containing the phrase"); + } + + /** + * Print the Horizontal Line that seperates between different user Inputs + */ + public void printHorizontalLine() { + for (int i = 0; i <= 30; i++) { + System.out.print("_"); + } + System.out.println(); + } + + /** + * Print the message for user to signal that Duke cannot understand the input + */ + public void printfalseInput() { + System.out.println("Sorry Duke could not understand your input :> please follow the instructions"); + printInstructions(); + } + + /** + * Print the Greeting when Duke is started + */ + public void printGreeting() { + String logo = " ____ _ \n" + + "| _ \\ _ _| | _____ \n" + + "| | | | | | | |/ / _ \\\n" + + "| |_| | |_| | < __/\n" + + "|____/ \\__,_|_|\\_\\___|\n"; + System.out.println("Hello from\n" + logo); + System.out.println("Hello! I'm Duke"); + System.out.println("What can I do for you ?"); + printHorizontalLine(); + printInstructions(); + printHorizontalLine(); + } + + /** + * Print the Goodbye message when user exits Duke + */ + public void printGoodbye() { + System.out.println("Thanks for using Duke! See ya!"); + System.out.println(" /\\_/\\ "); + System.out.println("( o.o ) "); + System.out.println(" > ^ < "); + } + +} diff --git a/src/main/java/duke/load.txt b/src/main/java/duke/load.txt new file mode 100644 index 000000000..0f5965f8c --- /dev/null +++ b/src/main/java/duke/load.txt @@ -0,0 +1,3 @@ + [T][ ] this + [T][ ] that + [T][ ] wut