[H1410101] iP

src/main/java/catbot/CatBot.java

@@ -0,0 +1,102 @@
+package catbot;
+
+import catbot.internal.CommandMap;
+import catbot.internal.CommandPattern;
+import catbot.internal.NamedParameterMap;
+import catbot.io.CatbotConsoleIO;
+import catbot.io.ErrorIndicatorIo;
+import catbot.io.UserIo;
+import catbot.task.Task;
+import catbot.task.TaskList;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+
+public class CatBot {
+
+    private static final CommandMap commands = new CommandMap();
+    static final UserIo io = new CatbotConsoleIO();
+    private static final TaskList taskList = new TaskList("Tasks.txt");
+    static {
+        addSupportedCommandsToCommandMap();
+    }
+
+    private static void addSupportedCommandsToCommandMap() {
+        CommandPattern<Integer> integerPattern = CatBotCommandPatterns.getIntegerPatternGenerator()
+                .generate(io::indicateInvalidInteger);
+        CommandPattern<NamedParameterMap> slashPattern = CatBotCommandPatterns.getSlashPatternGenerator()
+                .generate(CatBotCommandPatterns.NO_DEFAULT);
+
+        commands.setDefaultCommand(io::indicateInvalidCommand)
+                .addCommand("bye", args -> io.cleanup())
+                .addCommand("list", args -> io.printTaskList(taskList));
+
+        // User modifying existing tasks (through IntegerPattern, and Index)
+        BiConsumer<String, Consumer<Integer>> runIfValidIndexElseIndicateError =
+                (args, lambda) -> integerPattern.ifParsableElseDefault(args,
+                        integer -> taskList.ifValidIndexElse(integer,
+                                lambda,
+                                invalidIndex -> io.indicateInvalidIndex(invalidIndex, taskList.getIndexBounds())
+                        ));
+
+                //noinspection SpellCheckingInspection
+        commands.addCommand("mark",
+                        string -> runIfValidIndexElseIndicateError.accept(string,
+                                validIndex -> {
+                                    taskList.markTask(validIndex-1);
+                                    io.printTaskModified(taskList, validIndex);
+                                }
+                        )
+                )
+                .addCommand("unmark",
+                        string -> runIfValidIndexElseIndicateError.accept(string,
+                                validIndex -> {
+                                    taskList.unmarkTask(validIndex-1);
+                                    io.printTaskModified(taskList, validIndex);
+                                }
+                        )
+                )
+                .addCommand("delete",
+                        string -> runIfValidIndexElseIndicateError.accept(string,
+                                validIndex -> io.printTaskDeleted(taskList.removeTask(validIndex-1))
+                        )
+                );
+
+        // User creating new tasks (with SlashPattern)
+
+        BiConsumer<String, BiFunction<NamedParameterMap, BiConsumer<ErrorIndicatorIo.InvalidState, NamedParameterMap>, Optional<Task>>>
+                createTaskIfValidElseWarn = (args, bifunction) -> slashPattern.ifParsableElseDefault(args,
+                        namedParameterMap -> bifunction.apply(
+                                namedParameterMap,
+                                io::indicateArgumentInvalid
+                        ).ifPresent(task -> {
+                            taskList.addTask(task);
+                            io.printTaskAdded(taskList);
+                        })
+                );
+
+        commands.addCommand("todo",
+                        args -> createTaskIfValidElseWarn.accept(args, Task.Todo::createIfValidElse)
+                )
+                .addCommand("event",
+                        args -> createTaskIfValidElseWarn.accept(args, Task.Event::createIfValidElse)
+                )
+                .addCommand("deadline",
+                        args -> createTaskIfValidElseWarn.accept(args, Task.Deadline::createIfValidElse)
+                )
+        ;
+
+    }
+
+    public static void main(String[] args) {
+        UserIo.CommandArgument commandArgument;
+        io.initialize();
+        do {
+            commandArgument = io.getNextCommand();
+            commands.run(commandArgument.getCommand(), commandArgument.getArgument());
+        } while (!Objects.equals(commandArgument.getCommand(), "bye"));
+    }
+}

src/main/java/catbot/CatBotCommandPatterns.java

@@ -0,0 +1,63 @@
+package catbot;
+
+import catbot.internal.CommandPattern;
+import catbot.internal.CommandPatternGenerator;
+import catbot.internal.NamedParameterMap;
+
+import java.util.function.Consumer;
+
+public class CatBotCommandPatterns {
+
+    public static final Consumer<String> NO_DEFAULT = new Consumer<String>() {
+        @Override
+        public void accept(String s) {
+            assert false; //SHOULD NOT BE CALLED
+        }
+    };
+
+    //region Integer Pattern
+    public static CommandPatternGenerator<Integer> getIntegerPatternGenerator() {
+        return integerPatternGenerator;
+    }
+    private static final IntegerPatternGenerator integerPatternGenerator = new IntegerPatternGenerator();
+    private static class IntegerPatternGenerator implements CommandPatternGenerator<Integer> {
+
+        @Override
+        public CommandPattern<Integer> generate(Consumer<String> invalidInput) {
+            return new CommandPattern<Integer>() {
+                @Override
+                public void ifParsableElseDefault(String args, Consumer<Integer> consumer) {
+                    try {
+                        consumer.accept(Integer.parseInt(args));
+                    } catch (NumberFormatException nfe) {
+                        invalidInput.accept(args);
+                    }
+                }
+            };
+        }
+    }
+    //endregion
+
+    //region Slash Arguments Pattern
+    private static final SlashArgumentPatternGenerator slashPatternGenerator = new SlashArgumentPatternGenerator();
+    public static CommandPatternGenerator<NamedParameterMap> getSlashPatternGenerator() {
+        return slashPatternGenerator;
+    }
+
+    private static class SlashArgumentPatternGenerator implements CommandPatternGenerator<NamedParameterMap> {
+
+        @Override
+        public CommandPattern<NamedParameterMap> generate(Consumer<String> ignored) {
+            return new CommandPattern<NamedParameterMap>() {
+
+                private final Parser slashParser = Parser.by("/", true);
+                @Override
+                public void ifParsableElseDefault(String args, Consumer<NamedParameterMap> consumer) {
+                    consumer.accept(slashParser.parse(args));
+                }
+            };
+        }
+    }
+    //endregion
+
+}

src/main/java/catbot/Parser.java

@@ -0,0 +1,80 @@
+package catbot;
+
+import catbot.internal.NamedParameterMap;
+
+import java.util.Arrays;
+
+public class Parser {
+
+    private final String delimiter;
+    private final boolean emptyArgument;
+
+    //region Constructor
+
+    private Parser(String delimiter, boolean emptyArgument) {
+        this.delimiter = delimiter;
+        this.emptyArgument = emptyArgument;
+    }
+
+    public static Parser by(String delimiter) {
+        return by(delimiter, false);
+    }
+
+    public static Parser by(String delimiter, boolean emptyArgument) {
+        if (delimiter == null || delimiter.isEmpty()) {
+            return new SingleParser();
+        } else {
+            return new Parser(delimiter, emptyArgument);
+        }
+    }
+    //endregion
+
+    public static class SingleParser extends Parser {
+
+        private SingleParser() {
+            super(null, false);
+        }
+
+        @Override
+        public NamedParameterMap parse(String s) {
+            NamedParameterMap cmdArgs = new NamedParameterMap();
+            parseCmdArg(s, cmdArgs);
+            return cmdArgs;
+        }
+    }
+
+    public NamedParameterMap parse(String s) {
+        NamedParameterMap cmdArgs = new NamedParameterMap();
+        String[] arr = s.split(delimiter);
+        parseCmdArg(arr[0], cmdArgs, this.emptyArgument);
+        Arrays.stream(arr).skip(1).forEach(segment -> parseCmdArg(segment, cmdArgs));
+        return cmdArgs;
+    }
+
+    //region Internal Helpers
+
+    /**
+     * Split string into one pair of command + argument based on the first whitespace.
+     * @param s string containing both command and argument, in that order
+     * @param map to store the mapping between command and argument
+     */
+    private static void parseCmdArg(String s, NamedParameterMap map) {
+        String[] cmdArg = s.split("\\s", 2);
+        if (cmdArg.length == 2) {
+            map.addNamedParameter(cmdArg[0].trim(), cmdArg[1].trim());
+        } else {
+            map.addNamedParameter(cmdArg[0].trim(), "");
+        }
+    }
+
+    private static void parseCmdArg(String s, NamedParameterMap map, boolean emptyArgument) {
+        if (emptyArgument) {
+            map.addNamedParameter("", s.trim());
+        } else {
+            parseCmdArg(s, map);
+        }
+    }
+
+    //endregion
+
+}

src/main/java/catbot/internal/Command.java

@@ -0,0 +1,6 @@
+package catbot.internal;
+
+public interface Command {
+
+    public void run(String args);
+}

src/main/java/catbot/internal/CommandMap.java

@@ -0,0 +1,24 @@
+package catbot.internal;
+
+import java.util.HashMap;
+
+public class CommandMap {
+
+    private final HashMap<String, Command> commandMap = new HashMap<>();
+    private Command defaultCommand;
+    //endregion
+
+    public CommandMap addCommand(String invocation, Command lambda) {
+        commandMap.put(invocation, lambda);
+        return this;
+    }
+
+    public CommandMap setDefaultCommand(Command defaultCommand) {
+        this.defaultCommand = defaultCommand;
+        return this;
+    }
+
+    public void run(String s, String args) {
+        commandMap.getOrDefault(s, defaultCommand).run(args);
+    }
+}

src/main/java/catbot/internal/CommandPattern.java

@@ -0,0 +1,11 @@
+package catbot.internal;
+
+import java.util.function.Consumer;
+
+public abstract class CommandPattern<T> {
+
+    protected Consumer<String> invalidCommandInput;
+
+    public abstract void ifParsableElseDefault(String args, Consumer<T> consumer);
+
+}

src/main/java/catbot/internal/CommandPatternGenerator.java

@@ -0,0 +1,7 @@
+package catbot.internal;
+
+import java.util.function.Consumer;
+
+public interface CommandPatternGenerator<T> {
+    public CommandPattern<T> generate(Consumer<String> invalidInput);
+}

src/main/java/catbot/internal/NamedParameterMap.java

@@ -0,0 +1,37 @@
+package catbot.internal;
+
+import java.util.HashMap;
+import java.util.Set;
+
+public class NamedParameterMap {
+
+    private HashMap<String, String> parameters;
+
+    public NamedParameterMap() {
+        parameters = new HashMap<>();
+    }
+
+    public boolean containsKey(String key) {
+        return parameters.containsKey(key);
+    }
+
+    public void moveToNewKey(String oldKey, String newKey) {
+        if (!parameters.containsKey(newKey) && parameters.containsKey(oldKey)) {
+            parameters.put(newKey, parameters.get(oldKey));
+            parameters.remove(oldKey);
+        }
+    }
+
+    public Set<String> keySet() {
+        return parameters.keySet();
+    }
+
+    public String get(String key) {
+        return parameters.get(key);
+    }
+
+    public NamedParameterMap addNamedParameter(String parameterName, String parameterValue) {
+        parameters.put(parameterName, parameterValue);
+        return this;
+    }
+}