[Ryan Chew] Duke Increments

src/main/java/Command.java

@@ -0,0 +1,52 @@
+import java.util.Map;
+import java.util.HashMap;
+import java.util.regex.Pattern;
+public class Command {
+	public final String type;
+	public final String arguments;
+	public final Map<String,String> namedArguments;
+
+	public Command(String type, String arguments, Map<String, String> namedArguments) {
+		this.type = type;
+		this.arguments = arguments;
+		this.namedArguments = namedArguments;
+	}
+
+	private static final Pattern switchBoundary = Pattern.compile("\\s+/");
+	private static final Pattern cmdBoundary = Pattern.compile("\\s+");
+
+	public static Command parse(String input) {
+		input = input.trim();
+
+		//Split on the presence of any switches
+		String[] splits = switchBoundary.split(input);
+
+		//First split value is "cmd-type args..."
+		String[] mainArgs = cmdBoundary.split(splits[0], 2);
+		if(mainArgs[0].isEmpty()) {
+			return null;
+		}
+
+		String type = mainArgs[0];
+		//If no arguments, leave as empty string
+		String arguments = mainArgs.length > 1 ? mainArgs[1] : "";
+		Map<String, String> namedArguments = new HashMap<>();
+
+		if(splits.length > 1) {
+			//Each split value is "switch-name args..."
+			//with no preceding slash
+			for(int i=1;i<splits.length;i++) {
+				if(splits[i].isEmpty()) {
+					continue;
+				}
+				//Split at first whitespace
+				String[] switchArgs = cmdBoundary.split(splits[i], 2);
+				String switchName = switchArgs[0];
+				//If no arguments, leave as empty string
+				String switchArguments = switchArgs.length > 1 ? switchArgs[1] : "";
+				namedArguments.put(switchName, switchArguments);
+			}
+		}
+		return new Command(type, arguments, namedArguments);
+	}
+}

src/main/java/Duke.java

@@ -27,39 +27,40 @@ private void addTask(Task t) {
 				);
 	}
 
-	private boolean handleBye(String input) {
+	private boolean handleBye(Command input) {
 		this.io.say("Bye. Hope to see you again soon!");
 		return true;
 	}
 
-	private boolean displayList(String input) {
+	private boolean displayList(Command input) {
 		this.io.say(this.taskList.stream()
 				.map(Object::toString)
 				.map(new CounterDecorator(1))
 				.iterator());
 		return false;
 	}
 
-	private static final String bySwitch = " /by ";
-	private boolean makeDeadlineTask(String input) {
-		int deadlineIndex = input.indexOf(bySwitch);
-		String description = input.substring(0, deadlineIndex);
-		String deadline = input.substring(deadlineIndex + bySwitch.length());
+	private boolean makeDeadlineTask(Command input) {
+		String description = input.arguments;
+		String deadline = input.namedArguments.get("by");
+		if(deadline == null) {
+			deadline = "unknown";
+		}
+
 		DeadlineTask task = new DeadlineTask(description, deadline);
+
 		this.addTask(task);
 		return false;
 	}
-
-	private boolean makeToDoTask(String input) {
-		Task task = new Task(input);
-		this.addTask(task);
+	private boolean makeToDoTask(Command input) {
+		this.addTask(new Task(input.arguments));
 		return false;
 	}
 
-	private boolean markAsDone(String input) {
+	private boolean markAsDone(Command input) {
 		int index;
 		try {
-			index = Integer.parseInt(input);
+			index = Integer.parseInt(input.arguments);
 		} catch(NumberFormatException e) {
 			this.io.say("Index provided was not an integer!");
 			return false;
@@ -84,7 +85,7 @@ private Duke() {
 		this.io.bindCommand("done", this::markAsDone);
 		this.io.bindCommand("bye", this::handleBye);
 		this.io.bindCommand("deadline", this::makeDeadlineTask);
-		this.io.setUnknownCommandHandler(this::makeToDoTask);
+		this.io.bindCommand("todo", this::makeToDoTask);
 
 		this.taskList = new ArrayList<>();
 	}

src/main/java/DukeIO.java

@@ -10,14 +10,14 @@ public class DukeIO {
 	private static final String lineRule =
 		"____________________________________________________________";
 
-	private final Map<String, Predicate<String>> commandMap
+	private final Map<String, Predicate<Command>> commandMap
 		= new HashMap<>();
-	private Predicate<String> defaultHandler = null;
+	private Predicate<Command> defaultHandler = null;
 
-	private final Scanner parser;
+	private final Scanner scanner;
 
 	public DukeIO() {
-		this.parser = new Scanner(System.in);
+		this.scanner = new Scanner(System.in);
 	}
 
 	public void say(String... lines) {
@@ -37,36 +37,31 @@ public void say(Iterator<String> lines) {
 		System.out.println();
 	}
 
-	public void bindCommand(String command, Predicate<String> handler) {
+	public void bindCommand(String command, Predicate<Command> handler) {
 		this.commandMap.put(command, handler);
 	}
 
-	public void setUnknownCommandHandler(Predicate<String> handler) {
+	public void setUnknownCommandHandler(Predicate<Command> handler) {
 		this.defaultHandler = handler;
 	}
 
 	public void listen() {
 		//While there is still input from user
-		while(parser.hasNextLine()) {
+		while(scanner.hasNextLine()) {
 			//Read single line of user input, and remove extra spaces
-			String userInput = parser.nextLine().trim();
+			String userInput = scanner.nextLine();
 
-			int spacePos = userInput.indexOf(' ');
-			String command, rest;
-			if(spacePos == -1) {
-				command = userInput;
-				rest = null;
-			} else {
-				command = userInput.substring(0, spacePos);
-				rest = userInput.substring(spacePos+1);
-			}
+			Command command = Command.parse(userInput);
 
-			Predicate<String> cmdHandler = commandMap.get(command);
+			Predicate<Command> cmdHandler = commandMap.get(command.type);
 			boolean shouldExit;
 			if(cmdHandler != null) {
-				shouldExit = cmdHandler.test(rest);
+				shouldExit = cmdHandler.test(command);
+			} else if(defaultHandler != null) {
+				shouldExit = defaultHandler.test(command);
 			} else {
-				shouldExit = defaultHandler.test(userInput);
+				say(String.format("Unknown command %s", command.type));
+				shouldExit = false;
 			}
 
 			if(shouldExit) {