[Pranav Ganesh] iP

.gitignore

@@ -2,6 +2,7 @@
 /.idea/
 /out/
 /*.iml
+out/artifacts/ip_jar
 
 # Gradle build files
 /.gradle/

src/main/java/Duke.java

@@ -1,10 +1,37 @@
+import duke.Storage;
+import duke.task.TaskList;
+import duke.Ui;
+import duke.Parser;
+import duke.command.Command;
+
 public class Duke {
+    private Storage storage;
+    private TaskList taskList;
+    private Ui ui;
+
+    public Duke(String filePath) {
+        taskList = new TaskList();
+        storage = new Storage(filePath);
+        ui = new Ui(taskList, storage);
+    }
+
+    public void run() {
+        ui.showWelcome();
+        ui.showLine();
+        boolean isExit = false;
+        while (!isExit) {
+            String command = ui.command();
+            Parser parser = new Parser(command);
+            if (parser.isExit()) {
+                break;
+            }
+            Command c = parser.parse();
+            c.execute(taskList, storage);
+            isExit = parser.isExit();
+        }
+    }
+
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        new Duke("./duke.txt").run();
     }
-}
+}

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

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

src/main/java/duke/Parser.java

@@ -0,0 +1,60 @@
+package duke;
+
+import duke.command.*;
+
+public class Parser {
+    private String command;
+
+    public Parser(String command) {
+        this.command = command;
+    }
+
+    public Command parse() {
+        if (command.equals("list")) {
+            return new listCommand(command);
+        } else if (command.startsWith("done") && Character.isDigit(command.charAt(command.length() - 1))
+                && command.length() <= 8 && !Character.isAlphabetic(command.charAt(command.length() - 2))
+                && Character.isDigit(command.charAt(5))) {
+            return new doneCommand(command);
+        } else {
+            if (command.startsWith("todo")) {
+                return new todoCommand(command);
+            } else if (command.startsWith("deadline")) {
+                return new deadlineCommand(command);
+            } else if (command.startsWith("event")) {
+                return new eventCommand(command);
+            } else if (command.startsWith("delete")) {
+                return new deleteCommand(command);
+            } else {
+                return new InvalidCommand(command);    
+            }
+        }
+    }    
+
+    public boolean isExit() {
+        if (command.equals("bye")) {
+            Ui.bye();
+            Ui.showLine();
+            return true;
+        }
+        if (command.equals("")) {
+            return true;
+        }
+        return false;
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/duke/ParserTest.java

@@ -0,0 +1,51 @@
+package duke;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+public class ParserTest {
+    @Test
+    public void isExit_commandBye_true() {
+        Assert.assertEquals(true, new Parser("bye").isExit());
+    }
+
+    @Test
+    public void isExit_commandEmptyString_true() {
+        Assert.assertEquals(true, new Parser("").isExit());
+    }
+
+    @Test
+    public void isExit_commandDeadline_false() {
+        Assert.assertEquals(false, new Parser("deadline book ticket/by 2016-09-22 1700").isExit());
+    }
+
+    @Test
+    public void parse_commandDeadline_success() {
+        Assert.assertEquals("This is a deadline command", new Parser("deadline book ticket/by 2016-09-22 1700").parse().toString());
+    }
+
+    @Test
+    public void parse_commandEvent_success() {
+        Assert.assertEquals("This is an event command", new Parser("event concert/at 2016-09-22 1900").parse().toString());
+    }
+
+    @Test
+    public void parse_commandTodo_success() {
+        Assert.assertEquals("This is a todo command", new Parser("todo play cricket").parse().toString());
+    }
+
+    @Test
+    public void parse_commandDelete_success() {
+        Assert.assertEquals("This is a delete command", new Parser("delete 1").parse().toString());
+    }
+
+    @Test
+    public void parse_commandDone_success() {
+        Assert.assertEquals("This is a done command", new Parser("done 1").parse().toString());
+    }
+
+    @Test
+    public void parse_commandInvalidString_success() {
+        Assert.assertEquals("This is an invalid command", new Parser("Some invalid string").parse().toString());
+    }
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,84 @@
+package duke;
+
+import duke.task.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Scanner;
+
+public class Storage {
+    private String filepath;
+    private File file;
+
+    public Storage(String filepath) {
+        this.filepath = filepath;
+        try {
+            File file = new File(filepath);
+            if (!file.exists()) {
+                file.createNewFile();
+            }
+            this.file = file;
+        } catch (IOException e) {
+            System.out.println("Something went wrong: " + e.getMessage());
+        }
+    }
+
+    public void loadTaskListData(TaskList taskList) {
+        try {
+            Scanner s = new Scanner(this.file); // create a Scanner using the File as the source
+            if (!s.hasNext()) {
+                Ui.printMessage("There are no items in your task list!");
+            } else {
+                Ui.printMessage("Here is your current task list: ");
+                while (s.hasNext()) {
+                    String str = s.nextLine();
+                    System.out.println(str);
+                    String[] parts = str.split("\\|", 4);
+                    String subStr = parts[0].substring(3).trim();
+                    if (subStr.equals("duke.task.Todo") || subStr.equals("duke.task.Todo")) {
+                        Task task = new Todo(parts[2].trim());
+                        if (parts[1].trim().equals("X")) {
+                            task.markAsDone();
+                        }
+                        taskList.addTask(task);
+                    } else if (subStr.equals("duke.task.Deadline") || subStr.equals("duke.task.Deadline")) {
+                        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("MMM d yyyy, h a");
+                        LocalDateTime dateTime = LocalDateTime.parse(parts[3].substring(5).trim(), dtf);
+                        Task task = new Deadline(parts[2].trim(), dateTime);
+                        if (parts[1].trim().equals("X")) {
+                            task.markAsDone();
+                        }
+                        taskList.addTask(task);
+                    } else {
+                        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("MMM d yyyy, h a");
+                        LocalDateTime dateTime = LocalDateTime.parse(parts[3].substring(5).trim(), dtf);
+                        Task task = new Event(parts[2].trim(), dateTime);
+                        if (parts[1].trim().equals("X")) {
+                            task.markAsDone();
+                        }
+                        taskList.addTask(task);
+                    } 
+                }
+                Ui.printMessage("End of task list");
+            }
+        } catch (FileNotFoundException e) {
+            System.out.println("File not found!");
+        }
+    }
+
+    public void writeToFile(String filePath, TaskList tl) {
+        try {
+            FileWriter fw = new FileWriter(filePath);
+            for (int i = 0; i < tl.size(); i++) {
+                int num = i + 1;
+                fw.write(num + ". " + tl.getTask(i).taskListOnDisk() + "\n");
+            }
+            fw.close();
+        } catch (IOException e) {
+            System.out.println("Something went wrong: " + e.getMessage());
+        }
+    }
+}

src/main/java/duke/Ui.java

@@ -0,0 +1,74 @@
+package duke;
+
+import duke.task.Task;
+import duke.task.TaskList;
+import java.util.Scanner;
+
+public class Ui {
+    Scanner sc;
+    private static TaskList taskList;
+    private static Storage storage;
+
+    public Ui(TaskList taskList, Storage storage) {
+       sc = new Scanner(System.in);
+       this.taskList = taskList;
+       this.storage = storage;
+    }
+
+    public String command() {
+        if (sc.hasNextLine()) {
+            String str = sc.nextLine();
+            return str;
+        }
+        return "";
+    }
+
+    public void showWelcome() {
+        System.out.println("Hello from Duke!");
+        System.out.println("");
+        storage.loadTaskListData(taskList);
+        System.out.println("");
+        System.out.println("Hope you are doing well. How can I help you?");
+    }
+
+    public static void bye() {
+        System.out.println("Bye. Have a great day!");
+    }
+
+    public static void showLine() {
+        System.out.println("-----------------------------------------------");
+    }
+
+    public static void printMessage(String msg) {
+        System.out.println(msg);
+    }
+
+    public static void taskResponse(Task task) {
+        System.out.println("Got it. I've added this task:");
+        System.out.println(task);
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+    }
+
+    public static void doneResponse(Task task) {
+        System.out.println("Nice! I've marked this task as done:");
+        System.out.println(task);
+        storage.writeToFile("./duke.txt", taskList);
+    }
+
+    public static void deleteResponse(Task task) {
+        System.out.println("Noted. I've removed this task:");
+        System.out.println(task);
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+    }
+}
+
+
+
+
+
+
+
+
+
+
+

src/main/java/duke/command/Command.java

@@ -0,0 +1,14 @@
+package duke.command;
+
+import duke.Storage;
+import duke.task.TaskList;
+
+public abstract class Command {
+    private String command;
+
+    public Command(String command) {
+        this.command = command;
+    }
+
+    public abstract void execute(TaskList taskList, Storage storage);
+}

src/main/java/duke/command/InvalidCommand.java

@@ -0,0 +1,24 @@
+package duke.command;
+
+import duke.exception.DukeException;
+import duke.exception.InvalidCommandException;
+import duke.Storage;
+import duke.task.TaskList;
+
+public class InvalidCommand extends Command {
+    private String command;
+
+    public InvalidCommand(String command) {
+        super(command);
+        this.command = command;
+    }
+
+    public String toString() {
+        return "This is an invalid command";
+    }
+
+    public void execute(TaskList taskList, Storage storage) {
+        DukeException exp = new InvalidCommandException("OOPS!!! I'm sorry, but I don't know what that means :-(");
+        System.out.println(exp);
+    }
+}