UndoableCommand: Update redo() restore previous view before executing

The method `undo()` sets the `Addressbook` view to show all
persons after restoring the `Addressbook` state.

This leads to `redo()` potentially executing its command
on the incorrect `Person` due to different indexing in
different views.

Let's update
* `UndoableCommand` to store the predicate for the current view
* `redo()` method to reset the view to its previous state
before executing its command again.

src/main/java/seedu/address/logic/commands/UndoableCommand.java

@@ -4,15 +4,20 @@
 import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
 import static seedu.address.model.Model.PREDICATE_SHOW_ALL_PERSONS;
 
+import java.util.Optional;
+import java.util.function.Predicate;
+
 import seedu.address.logic.commands.exceptions.CommandException;
 import seedu.address.model.AddressBook;
 import seedu.address.model.ReadOnlyAddressBook;
+import seedu.address.model.person.ReadOnlyPerson;
 
 /**
  * Represents a command which can be undone and redone.
  */
 public abstract class UndoableCommand extends Command {
     private ReadOnlyAddressBook previousAddressBook;
+    private Optional<Predicate<ReadOnlyPerson>> previousPredicate = Optional.empty();
 
     protected abstract CommandResult executeUndoableCommand() throws CommandException;
 
@@ -24,6 +29,13 @@ private void saveAddressBookSnapshot() {
         this.previousAddressBook = new AddressBook(model.getAddressBook());
     }
 
+    /**
+     * Stores the current state of {@code model#filteredPersonList#Predicate}
+     */
+    private void savePredicateSnapshot() {
+        previousPredicate = Optional.ofNullable(model.getFilteredPersonListPredicate());
+    }
+
     /**
      * Reverts the AddressBook to the state before this command
      * was executed and updates the filtered person list to
@@ -42,6 +54,7 @@ protected final void undo() {
     protected final void redo() {
         requireNonNull(model);
         try {
+            previousPredicate.ifPresent(model::updateFilteredPersonList);
             executeUndoableCommand();
         } catch (CommandException ce) {
             throw new AssertionError("The command has been successfully executed previously; "
@@ -53,6 +66,7 @@ protected final void redo() {
     @Override
     public final CommandResult execute() throws CommandException {
         saveAddressBookSnapshot();
+        savePredicateSnapshot();
         return executeUndoableCommand();
     }
 }

src/test/java/systemtests/DeleteCommandSystemTest.java

@@ -60,11 +60,23 @@ public void delete() {
         /* ------------------ Performing delete operation while a filtered list is being shown ---------------------- */
 
         /* Case: filtered person list, delete index within bounds of address book and person list -> deleted */
+        Model modelBeforeDeletingFirstFiltered = getModel();
         showPersonsWithName(KEYWORD_MATCHING_MEIER);
         Index index = INDEX_FIRST_PERSON;
         assertTrue(index.getZeroBased() < getModel().getFilteredPersonList().size());
         assertCommandSuccess(index);
 
+        /* Case: undo deleting the first person in the filtered list -> first person in filtered list restored */
+        command = UndoCommand.COMMAND_WORD;
+        expectedResultMessage = UndoCommand.MESSAGE_SUCCESS;
+        assertCommandSuccess(command, modelBeforeDeletingFirstFiltered, expectedResultMessage);
+
+        /* Case: redo deleting the first person in the filtered list -> first person in filtered list deleted again */
+        command = RedoCommand.COMMAND_WORD;
+        removePerson(modelBeforeDeletingFirstFiltered, index);
+        expectedResultMessage = RedoCommand.MESSAGE_SUCCESS;
+        assertCommandSuccess(command, modelBeforeDeletingFirstFiltered, expectedResultMessage);
+
         /* Case: filtered person list, delete index within bounds of address book but out of bounds of person list
          * -> rejected
          */

src/test/java/systemtests/EditCommandSystemTest.java

@@ -101,6 +101,7 @@ public void edit() throws Exception {
         /* ------------------ Performing edit operation while a filtered list is being shown ------------------------ */
 
         /* Case: filtered person list, edit index within bounds of address book and person list -> edited */
+        model  = getModel();
         showPersonsWithName(KEYWORD_MATCHING_MEIER);
         index = INDEX_FIRST_PERSON;
         assertTrue(index.getZeroBased() < getModel().getFilteredPersonList().size());
@@ -109,6 +110,17 @@ public void edit() throws Exception {
         editedPerson = new PersonBuilder(personToEdit).withName(VALID_NAME_BOB).build();
         assertCommandSuccess(command, index, editedPerson);
 
+        /* Case: undo editing the first person in the filtered list -> first person in filtered list restored */
+        command = UndoCommand.COMMAND_WORD;
+        expectedResultMessage = UndoCommand.MESSAGE_SUCCESS;
+        assertCommandSuccess(command, model, expectedResultMessage);
+
+        /* Case: redo editing the first person in the filtered list -> first person in filtered list edited again */
+        command = RedoCommand.COMMAND_WORD;
+        expectedResultMessage = RedoCommand.MESSAGE_SUCCESS;
+        model.updatePerson(personToEdit, editedPerson);
+        assertCommandSuccess(command, model, expectedResultMessage);
+
         /* Case: filtered person list, edit index within bounds of address book but out of bounds of person list
          * -> rejected
          */