[Sherman Ho] iP

data/.gitignore

@@ -0,0 +1,3 @@
+*
+*/
+!.gitignore

src/main/java/duke/Duke.java

@@ -0,0 +1,59 @@
+package duke;
+
+import duke.command.Command;
+import duke.exception.BadDateArgumentException;
+import duke.exception.EmptyArgumentException;
+import duke.exception.InvalidCommandException;
+
+import java.io.IOException;
+import java.text.ParseException;
+import java.util.Scanner;
+
+public class Duke {
+    public static void main(String[] args) {
+        Ui ui = new Ui();
+        ui.startUpMessage();
+        TaskList store;
+        try {
+            ui.loadStart();
+            store = Storage.LoadTaskList();
+            ui.loadSuccess();
+        } catch (IOException e) {
+            ui.loadFail();
+            return;
+        }
+        Scanner in = new Scanner(System.in);
+        String line;
+        do{
+            ui.prompt();
+            line = in.nextLine();
+            try {
+                Command c = Parser.parse(line);
+                if (c==null){ //Bye command
+                    break;
+                }
+                String data = store.run(c);
+                ui.commandMessage(c,data);
+            } catch (ParseException e) {
+                ui.handleException(e);
+            } catch (InvalidCommandException e){
+                ui.handleException(e);
+            } catch(EmptyArgumentException e){
+                ui.handleException(e);
+            } catch (BadDateArgumentException e) {
+                ui.handleException(e);
+            } finally {
+                if(store.isEdited()){
+                    try {
+                        Storage.saveTaskList(store);
+                        store.markSaved();
+                    } catch (IOException e) {
+                        ui.dumpState(store);
+                    }
+                }
+            }
+        }while(true);
+        ui.goodByeMessage();
+        in.close();
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,71 @@
+package duke;
+
+import duke.command.*;
+import duke.exception.InvalidCommandException;
+
+import java.text.ParseException;
+import java.util.Arrays;
+import java.util.List;
+
+public class Parser {
+    public static Command parse(String line) throws ParseException, InvalidCommandException {
+        line = line.trim();
+        Command c = null;
+        String singleTokens[] = {"bye", "list", "exit", "ls"};
+        String[] tokens = splitTokenIntoTwo(line, " ", singleTokens);
+        switch (tokens[0].toLowerCase()) {
+        case "exit":
+            //Fall-through
+        case "bye":
+            //Leave as null
+            break;
+        case "ls":
+            //Fall-through
+        case "list":
+            c = new ListCommand();
+            break;
+        case "done":
+            c = new DoneCommand(Integer.parseInt(tokens[1]));
+            break;
+        case "todo":
+            c = new AddCommand(new String[]{"T", tokens[1]});
+            break;
+        case "deadline":
+            tokens = splitTokenIntoTwo(tokens[1], " /by ");
+            c = new AddCommand(new String[]{"D", tokens[0], tokens[1]});
+            break;
+        case "event":
+            tokens = splitTokenIntoTwo(tokens[1], " /at ");
+            c = new AddCommand(new String[]{"E", tokens[0], tokens[1]});
+            break;
+        case "rm":
+            //Fall-through
+        case "remove":
+            //Fall-through
+        case "del":
+            //Fall-through
+        case "delete":
+            c = new DeleteCommand(Integer.parseInt(tokens[1]));
+            break;
+        default:
+            throw new InvalidCommandException(tokens[0]);
+        }
+        return c;
+    }
+    private static String[] splitTokenIntoTwo(String parseTarget,String delimiter) throws ParseException {
+        String[] tokens = parseTarget.split(delimiter,2);
+        if (tokens.length < 2){
+            throw new ParseException("Expected deliminter '"+ delimiter +"'", tokens[0].length());
+        }
+        return tokens;
+    }
+
+    private static String[] splitTokenIntoTwo(String parseTarget,String delimiter, String[] exception) throws ParseException{
+        List<String> exceptionList = Arrays.asList(exception);
+        String[] tokens = parseTarget.split(delimiter,2);
+        if (!exceptionList.contains(tokens[0]) && tokens.length < 2){
+            throw new ParseException("Expected deliminter '"+ delimiter +"'", tokens[0].length());
+        }
+        return tokens;
+    }
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,109 @@
+package duke;
+
+import duke.exception.BadDateArgumentException;
+import duke.exception.EmptyArgumentException;
+import duke.task.Deadline;
+import duke.task.Event;
+import duke.task.Task;
+import duke.task.ToDos;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Storage {
+    public static final String FILE_DIR = "data";
+    public static final String FILE_NAME = "duke.txt";
+    static int badLines = 0;//Last call bad lines
+
+    public static TaskList LoadTaskList() throws IOException {
+        badLines = 0;
+        List<Task> store = new ArrayList<>();
+        File file = getOrCreateFile();
+        Scanner s = new Scanner(file);
+        generateLines: //TODO: Whats the code style for this.
+        while(s.hasNextLine()){
+            Task t;
+            String line = s.nextLine();
+            String pattern = "([TED]),([01]),(\\d*),(.*)";
+            Pattern r = Pattern.compile(pattern);
+            Matcher m = r.matcher(line);
+            if(!m.find()){
+                badLines++;
+                break;
+            }
+            String type = m.group(1);
+            boolean isDone = m.group(2).equals("1");
+            int taskLength = Integer.parseInt(m.group(3));
+            String task = m.group(4).substring(0,taskLength);
+            String leftover = m.group(4).substring(taskLength);
+            try {
+                if (type.equals("E") || type.equals("D") ) {
+                    line = leftover.substring(1);
+                    pattern = "(\\d*),(.*)";
+                    r = Pattern.compile(pattern);
+                    m = r.matcher(line);
+                    if (!m.find()) {
+                        badLines++;
+                        break;
+                    }
+                    int timeLength = Integer.parseInt(m.group(1));
+                    String timeData = m.group(2).substring(0, timeLength);
+
+                    switch (type) {
+                    case "E":
+                        t = new Event(task, timeData);
+                        break;
+                    case "D":
+                        t = new Deadline(task, timeData);
+                        break;
+                    default:
+                        badLines++;
+                        break generateLines;
+                    }
+                } else {
+                    t = new ToDos(task);
+                }
+            }catch(EmptyArgumentException e){
+                badLines++;
+                break;
+            }catch(BadDateArgumentException e){
+                badLines++;
+                break;
+            }
+            if (isDone){
+                t.setDone();
+            }
+            store.add(t);
+        }
+        s.close();
+        return new TaskList(store);
+    }
+
+    public static void saveTaskList(TaskList data) throws IOException {
+        List<Task> store = data.getRawData();
+        StringBuilder saveText = new StringBuilder();
+        for (Task t: store){
+            saveText.append(t.toFileString());
+            saveText.append('\n');
+        }
+        File f = getOrCreateFile();
+        FileWriter writer = new FileWriter(f);
+        writer.write(saveText.toString());
+        writer.close();
+    }
+
+    private static File getOrCreateFile() throws IOException {
+        Files.createDirectories(Paths.get(FILE_DIR));
+        File file = new File(FILE_DIR, FILE_NAME); // create a File for the given file path
+        file.createNewFile();
+        return file;
+    }
+}

src/main/java/duke/TaskList.java

@@ -0,0 +1,108 @@
+package duke;
+
+import duke.command.Command;
+import duke.exception.BadDateArgumentException;
+import duke.exception.EmptyArgumentException;
+import duke.task.Deadline;
+import duke.task.Event;
+import duke.task.Task;
+import duke.task.ToDos;
+
+import java.util.List;
+
+public class TaskList {
+    public enum Action{
+        ADD,
+        LIST,
+        DONE,
+        DELETE,
+    }
+    private boolean edited = false;
+    private List<Task> store;
+    public TaskList(List<Task> store) {
+        this.store = store;
+    }
+
+    public List<Task> getRawData(){
+        return this.store;
+    }
+
+    public String run(Command c) throws EmptyArgumentException, BadDateArgumentException {
+        String[] args = c.run();
+        String results;
+        switch(c.getType()){
+        case ADD:
+            results = addTask(args);
+            edited = true;
+            break;
+        case DONE:
+            results = setDone(Integer.parseInt(args[0]));
+            edited = true;
+            break;
+        case DELETE:
+            results = delete(Integer.parseInt(args[0]));
+            edited = true;
+            break;
+        case LIST:
+            results = getList();
+            break;
+        default:
+            results = "";
+            break;
+        }
+        return results;
+    }
+    public void markSaved(){
+        edited = false;
+    }
+    public boolean isEdited(){
+        return this.edited;
+    }
+    private String addTask(String[] tokens) throws EmptyArgumentException, BadDateArgumentException {
+        Task t;
+        switch(tokens[0]){
+        case "D":
+            t = new Deadline(tokens[1], tokens[2]);
+            break;
+        case "E":
+            t = new Event(tokens[1], tokens[2]);
+            break;
+        case "T":
+            //Fall through
+        default: //More fault tolerant
+            t = new ToDos(tokens[1]);
+            break;
+        }
+        store.add(t);
+        return formatOrderedPrint(-1);
+    }
+    private String setDone(int doneIndex){
+        Task t = store.get(doneIndex);
+        t.setDone();
+        return formatOrderedPrint(doneIndex);
+    }
+    private String delete(int deleteIndex){
+        String returnValue = formatOrderedPrint(deleteIndex);
+        store.remove(deleteIndex);
+        return returnValue;
+    }
+    public String getList(){
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0 ; i < store.size(); i++) {
+            builder.append(formatOrderedPrint(i));
+            builder.append('\n');
+        }
+        return builder.toString();
+    }
+
+    private String formatOrderedPrint(int i){
+        final int size = store.size();
+        while (i < 0){
+            i += size;
+        }
+        while (i >= size){
+            i -= size;
+        }
+        return "Entry " + (i+1) + "|" + store.get(i).toString();
+    }
+}