[Ryan Chew] Duke Increments

src/main/java/CounterDecorator.java

@@ -0,0 +1,13 @@
+import java.util.function.Function;
+
+class CounterDecorator implements Function<String, String> {
+	private int counter;
+	public CounterDecorator(int start) {
+		this.counter = start;
+	}
+	public String apply(String str) {
+		String ret = String.format("%d: %s", this.counter, str);
+		this.counter++;
+		return ret;
+	}
+}

src/main/java/Duke.java

@@ -1,10 +1,7 @@
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Scanner;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -16,123 +13,70 @@ public class Duke {
 		"What can I do for you?"
 	};
 
-	private static final String lineRule =
-		"____________________________________________________________";
+	private DukeIO io;
+	private final List<Task> taskList;
 
-	private static void say(String... lines) {
-		say(Arrays.asList(lines).iterator());
-	}
-	private static void say(Iterator<String> lines) {
-		//Print start of reply line
-		System.out.println(lineRule);
-
-		//Print each given line
-		while(lines.hasNext()) {
-			System.out.println(lines.next());
-		}
-
-		//Print end of reply line, and extra empty line
-		System.out.println(lineRule);
-		System.out.println();
-	}
-
-	static class CounterDecorator implements Function<String, String> {
-		private int counter;
-		public CounterDecorator(int start) {
-			this.counter = start;
-		}
-		public String apply(String str) {
-			String ret = String.format("%d: %s", this.counter, str);
-			this.counter++;
-			return ret;
-		}
-	}
-
-	private static final Map<String, Predicate<String>> commandMap
-		= new HashMap<>();
-	private static Predicate<String> defaultHandler;
-
-	private static final List<Task> taskList = new ArrayList<>();
-
-	private static boolean handleBye(String input) {
-		say("Bye. Hope to see you again soon!");
+	private boolean handleBye(String input) {
+		this.io.say("Bye. Hope to see you again soon!");
 		return true;
 	}
 
-	private static boolean displayList(String input) {
-		say(Duke.taskList.stream()
+	private boolean displayList(String input) {
+		this.io.say(this.taskList.stream()
 				.map(Object::toString)
 				.map(new CounterDecorator(1))
 				.iterator());
 		return false;
 	}
 
-	private static boolean addTask(String input) {
-		Duke.taskList.add(new Task(input));
-		say("added: " + input);
+	private boolean addTask(String input) {
+		this.taskList.add(new Task(input));
+		this.io.say("added: " + input);
 		return false;
 	}
 
-	private static boolean markAsDone(String input) {
+	private boolean markAsDone(String input) {
 		int index;
 		try {
 			index = Integer.parseInt(input);
 		} catch(NumberFormatException e) {
-			say("Index provided was not an integer!");
+			this.io.say("Index provided was not an integer!");
 			return false;
 		}
 
-		if(index < 0 || index > Duke.taskList.size()) {
-			say("There's no task with that index!");
+		if(index < 0 || index > this.taskList.size()) {
+			this.io.say("There's no task with that index!");
 			return false;
 		}
 
-		Task selectedTask = Duke.taskList.get(index-1);
+		Task selectedTask = this.taskList.get(index-1);
 		selectedTask.markComplete();
-		say("Nice! I've marked this task as done:",
+		this.io.say("Nice! I've marked this task as done:",
 			"  " + selectedTask);
 		return false;
 	}
 
-    public static void main(String[] args) {
+	private Duke() {
+		this.io = new DukeIO();
 		//Bind command handlers
-		Duke.commandMap.put("list", Duke::displayList);
-		Duke.commandMap.put("done", Duke::markAsDone);
-		Duke.commandMap.put("bye", Duke::handleBye);
-		Duke.defaultHandler = Duke::addTask;
+		this.io.bindCommand("list", this::displayList);
+		this.io.bindCommand("done", this::markAsDone);
+		this.io.bindCommand("bye", this::handleBye);
+		this.io.setUnknownCommandHandler(this::addTask);
 
-		//Initialize input.
-		Scanner s = new Scanner(System.in);
+		this.taskList = new ArrayList<>();
+	}
 
+	private void run() {
 		//Start off greeting the user.
-		say(initialGreeting);
-
-		//While there is still input from user
-		while(s.hasNextLine()) {
-			//Read single line of user input, and remove extra spaces
-			String userInput = s.nextLine().trim();
+		this.io.say(initialGreeting);
 
-			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);
-			}
-
-			Predicate<String> cmdHandler = commandMap.get(command);
-			boolean shouldExit;
-			if(cmdHandler != null) {
-				shouldExit = cmdHandler.test(rest);
-			} else {
-				shouldExit = defaultHandler.test(userInput);
-			}
+		//Start listen loop.
+		this.io.listen();
+	}
 
-			if(shouldExit) {
-				break;
-			}
-		}
+    public static void main(String[] args) {
+		Duke duke = new Duke();
+		duke.run();
     }
 }

src/main/java/DukeIO.java

@@ -0,0 +1,78 @@
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.function.Predicate;
+
+public class DukeIO {
+
+	private static final String lineRule =
+		"____________________________________________________________";
+
+	private final Map<String, Predicate<String>> commandMap
+		= new HashMap<>();
+	private Predicate<String> defaultHandler = null;
+
+	private final Scanner parser;
+
+	public DukeIO() {
+		this.parser = new Scanner(System.in);
+	}
+
+	public void say(String... lines) {
+		say(Arrays.asList(lines).iterator());
+	}
+	public void say(Iterator<String> lines) {
+		//Print start of reply line
+		System.out.println(lineRule);
+
+		//Print each given line
+		while(lines.hasNext()) {
+			System.out.println(lines.next());
+		}
+
+		//Print end of reply line, and extra empty line
+		System.out.println(lineRule);
+		System.out.println();
+	}
+
+	public void bindCommand(String command, Predicate<String> handler) {
+		this.commandMap.put(command, handler);
+	}
+
+	public void setUnknownCommandHandler(Predicate<String> handler) {
+		this.defaultHandler = handler;
+	}
+
+	public void listen() {
+		//While there is still input from user
+		while(parser.hasNextLine()) {
+			//Read single line of user input, and remove extra spaces
+			String userInput = parser.nextLine().trim();
+
+			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);
+			}
+
+			Predicate<String> cmdHandler = commandMap.get(command);
+			boolean shouldExit;
+			if(cmdHandler != null) {
+				shouldExit = cmdHandler.test(rest);
+			} else {
+				shouldExit = defaultHandler.test(userInput);
+			}
+
+			if(shouldExit) {
+				break;
+			}
+		}
+	}
+
+}