Merge branch 'branch-Level-9'

Merge branch 'branch-Level-9'

src/main/java/duke/commands/Command.java

@@ -14,6 +14,7 @@ public class Command {
     protected Duke duke;
     protected List<Task> taskList;
     private int targetIndex = -1;
+    private String targetString = "";
 
     /**
      * @param targetIndex last visible listing index of the target task
@@ -22,6 +23,13 @@ public Command(int targetIndex) {
         this.setTargetIndex(targetIndex);
     }
 
+    /**
+     * @param targetString String that is the target
+     */
+    public Command(String targetString) {
+        this.setTargetString(targetString);
+    }
+
     protected Command() {
     }
 
@@ -46,4 +54,13 @@ public int getTargetIndex() {
     public void setTargetIndex(int targetIndex) {
         this.targetIndex = targetIndex;
     }
+
+    public String getTargetString() {
+        return targetString;
+    }
+
+    public void setTargetString(String targetString) {
+        this.targetString = targetString;
+    }
+
 }

src/main/java/duke/commands/FindCommand.java

@@ -0,0 +1,43 @@
+package src.main.java.duke.commands;
+
+import src.main.java.duke.commons.Messages;
+import src.main.java.duke.data.task.Task;
+
+import java.util.List;
+
+public class FindCommand extends Command {
+
+    public static final String COMMAND_WORD = "find";
+
+    private static String INDENT = "   ";
+    // Message to add
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Find the tasks that contains the words. \n"
+            + "Parameters: find WORD\n" + "Example: " + COMMAND_WORD + " 1";
+
+    public static final String MESSAGE_SUCCESS = "Mark done task: %1$s";
+
+    public FindCommand(String targetVisibleString) {
+        super(targetVisibleString);
+    }
+
+    @Override
+    public CommandResult execute() {
+        try {
+            final String target = getTargetString();
+            List<Task> allTasks = duke.getTaskList().filteredView(target);
+            String result = "Display a list of tasks: \n";
+            if (allTasks.size() == 0 ) {
+                result = "There's nothing that contains in the list :(";
+            }
+            for (int i = 0; i < allTasks.size(); i++) {
+                result += INDENT + (i + 1) + "." + allTasks.get(i) + "\n";
+            }
+            return new CommandResult(result.trim());
+        } catch (IndexOutOfBoundsException ie) {
+            return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+        } catch (Exception pnfe) {
+            return new CommandResult(Messages.MESSAGE_TASK_NOT_IN_ADDRESSBOOK);
+        }
+    }
+
+}

src/main/java/duke/data/task/TaskList.java

@@ -44,6 +44,18 @@ public List<Task> immutableListView() {
         return Collections.unmodifiableList(internalList);
     }
 
+    /**
+     * Returns an unmodifiable java List view with elements cast as immutable {@link Task}s.
+     * For use with other methods/libraries.
+     * Any changes to the internal list/elements are immediately visible in the returned list.
+     */
+    public List<Task> filteredView(String searchString) {
+        List<Task> filteredList = internalList
+                .stream()
+                .filter(task -> task.description.contains(searchString)).collect(Collectors.toList());
+        return Collections.unmodifiableList(filteredList);
+    }
+
     /**
      * Checks if the list contains an equivalent person as the given argument.
      * defines a weaker notion of equality.

src/main/java/duke/parser/Parser.java

@@ -13,7 +13,10 @@ public class Parser {
 
     public static final Pattern TASK_INDEX_ARGS_FORMAT = Pattern.compile("(?<targetIndex>.+)");
 
-    public static final Pattern EVENT_TASK_DATA_ARGS_FORMAT = Pattern.compile("(?<description>[^/]+)+\\s+(\\/at)+\\s+"
+    public static final Pattern TASK_STRING_ARGS_FORMAT = Pattern.compile("(?<targetIndex>\\w.+)");
+
+    public static final Pattern EVENT_TASK_DATA_ARGS_FORMAT = // '/' forward slashes are reserved for delimiter prefixes
+            Pattern.compile("(?<description>[^/]+)+\\s+(\\/at)+\\s+"
                     + "(?<duedate>[\\d\\d\\d-\\d\\d\\-\\d\\d\\d+\\s+\\d\\d:\\d\\d]+)");
 
     public static final Pattern DEADLINE_TASK_DATA_ARGS_FORMAT =
@@ -43,22 +46,24 @@ public Command parseCommand(String userInput) {
         final String commandWord = matcher.group("commandWord");
         final String arguments = matcher.group("arguments");
         switch (commandWord) {
-        case ListCommand.COMMAND_WORD:
-            return new ListCommand();
-        case AddTodoCommand.COMMAND_WORD:
-            return prepareAddTodo(arguments);
-        case AddEventCommand.COMMAND_WORD:
-            return prepareAddEvent(arguments);
-        case AddDeadlineCommand.COMMAND_WORD:
-            return prepareAddDeadline(arguments);
-        case DeleteCommand.COMMAND_WORD:
-            return prepareDelete(arguments);
-        case ExitCommand.COMMAND_WORD:
-            return new ExitCommand();
-        case MarkDoneCommand.COMMAND_WORD:
-            return prepareMarkDone(arguments);
-        default:
-            return new HelpCommand();
+            case ListCommand.COMMAND_WORD:
+                return new ListCommand();
+            case AddTodoCommand.COMMAND_WORD:
+                return prepareAddTodo(arguments);
+            case AddEventCommand.COMMAND_WORD:
+                return prepareAddEvent(arguments);
+            case AddDeadlineCommand.COMMAND_WORD:
+                return prepareAddDeadline(arguments);
+            case DeleteCommand.COMMAND_WORD:
+                return prepareDelete(arguments);
+            case ExitCommand.COMMAND_WORD:
+                return new ExitCommand();
+            case MarkDoneCommand.COMMAND_WORD:
+                return prepareMarkDone(arguments);
+        case FindCommand.COMMAND_WORD:
+            return prepareFind(arguments);
+            default:
+                return new HelpCommand();
         }
     }
 
@@ -142,6 +147,24 @@ private Command prepareMarkDone(String args) {
         }
     }
 
+    /**
+     * Parses arguments in the context of the delete task command.
+     *
+     * @param args full command args string
+     * @return the prepared command
+     */
+    private Command prepareFind(String args) {
+        try {
+            final String targetString = parseArgsString(args);
+            return new FindCommand(targetString);
+        } catch (ParseException pe) {
+            return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, FindCommand.MESSAGE_USAGE));
+        } catch (NumberFormatException nfe) {
+            return new IncorrectCommand(MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+        }
+    }
+
+
     /**
      * Parses the given arguments string as a single index number.
      *
@@ -159,6 +182,23 @@ private int parseArgsAsDisplayedIndex(String args) throws ParseException, Number
         return Integer.parseInt(matcher.group("targetIndex"));
     }
 
+    /**
+     * Parses the given arguments string.
+     *
+     * @param args arguments string to parse as index number
+     * @return the parsed index number
+     * @throws ParseException        if no region of the args string could be found
+     *                               for the index
+     * @throws NumberFormatException the args string region is not a valid number
+     */
+    private String parseArgsString(String args) throws ParseException {
+        final Matcher matcher = TASK_STRING_ARGS_FORMAT.matcher(args.trim());
+        if (!matcher.matches()) {
+            throw new ParseException("Could not find index number to parse");
+        }
+        return matcher.group("targetIndex");
+    }
+
     /**
      * Signals that the user input could not be parsed.
      */

src/main/java/duke/ui/TextUi.java

@@ -63,7 +63,8 @@ private boolean isCommentLine(String rawInputLine) {
         if (!(rawInputLine.contains("bye") || rawInputLine.contains("done") || rawInputLine.contains("todo")
                 || rawInputLine.contains("deadline") || rawInputLine.contains("list")
                 || rawInputLine.contains("event") || rawInputLine.contains("delete")
-                || rawInputLine.contains("time") || rawInputLine.contains("help"))) {
+                || rawInputLine.contains("time") || rawInputLine.contains("help")
+                || rawInputLine.contains("find"))) {
             return true;
         }
         return false;