Merge pull request #12 from Zaiah0505/branch-touchup

Branch touchup

Author: zaiahkoh

src/main/java/Sweh.java

@@ -10,17 +10,29 @@
 import javafx.scene.layout.AnchorPane;
 import javafx.scene.layout.Region;
 import javafx.scene.layout.VBox;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontPosture;
+import javafx.scene.text.FontWeight;
 import javafx.stage.Stage;
 import nodes.DialogBox;
 import util.Storage;
 
+import java.io.IOException;
+
 /**
  * JavaFX Application used to wrap a Duke instance and provide GUI interaction
  * for Duke.
  */
 public class Sweh extends Application {
-    private final Image userImage = new Image(this.getClass().getResourceAsStream("/images/DaUser.png"));
-    private final Image dukeImage = new Image(this.getClass().getResourceAsStream("/images/DaDuke.png"));
+    private final Image userImage = new Image(this.getClass()
+            .getResourceAsStream("/images/DaUser.jpg"));
+    private final Image dukeImage = new Image(this.getClass()
+            .getResourceAsStream("/images/DaSweh.jpg"));
+    private final Label greetingText = new Label("Hello, I am SWEH. "
+            + "Your Simple Word-Executed Helper!\n"
+            + "What shall we do today?");
+    private final Label storageErrorText = new Label("A save file was found, "
+            + "but the contents could not be read... I will start from scratch instead.");
     private Duke duke;
     private ScrollPane scrollPane;
     private VBox dialogContainer;
@@ -51,7 +63,7 @@ public void start(Stage stage) {
         stage.show();
 
         //Step 2. Formatting the window to look as expected
-        stage.setTitle("Duke");
+        stage.setTitle("Sweh");
         stage.setResizable(false);
         stage.setMinHeight(600.0);
         stage.setMinWidth(400.0);
@@ -69,6 +81,9 @@ public void start(Stage stage) {
         dialogContainer.setPrefHeight(Region.USE_COMPUTED_SIZE);
 
         userInput.setPrefWidth(325.0);
+        userInput.setFont(Font.font("Consolas", FontWeight.BOLD,
+                FontPosture.REGULAR, 12));
+        userInput.setStyle("-fx-text-inner-color: saddlebrown");
 
         sendButton.setPrefWidth(55.0);
 
@@ -88,7 +103,20 @@ public void start(Stage stage) {
         //Scroll down to the end every time dialogContainer's height changes.
         dialogContainer.heightProperty().addListener((observable) -> scrollPane.setVvalue(1.0));
 
-        // more code to be added here later
+        //Show greeting text
+        dialogContainer.getChildren().addAll(
+                DialogBox.getDukeDialog(greetingText, new ImageView(dukeImage))
+        );
+
+        //Print error text if storage could not load a save file.
+        try {
+            storage.readTaskManager();
+        } catch (IOException e) {
+            dialogContainer.getChildren().addAll(
+                    DialogBox.getDukeDialog(storageErrorText, new ImageView(dukeImage))
+            );
+        }
+
     }
 
     /**

src/main/java/command/Command.java

@@ -3,9 +3,28 @@
 import task.TaskManager;
 import util.DukeException;
 
+/**
+ * Command class representing a future action that can be executed on the supplied
+ * TaskManager object.
+ */
 public abstract class Command {
+    /**
+     * Performs an action on the supplied taskManager and returns a String response
+     * based on the action that was performed.
+     *
+     * @param taskManager TaskManager object to perform the action on.
+     * @return String response of the action that was performed.
+     * @throws DukeException Whenever the supplied action cannot be performed on
+     *                       the given
+     */
     public abstract String execute(TaskManager taskManager) throws DukeException;
 
+    /**
+     * Indicates if the Command object should signal to the application that the
+     * user wants to terminate it.
+     *
+     * @return True, if the Command should tell the application to end.
+     */
     public boolean isQuitCommand() {
         return false;
     }

src/main/java/command/DeadlineCommand.java

@@ -3,30 +3,52 @@
 import task.Deadline;
 import task.TaskManager;
 import util.DukeException;
+import util.Parser;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 import java.util.HashMap;
 import java.util.List;
 
+/**
+ * Command to add a Deadline Task to a TaskManager.
+ */
 public class DeadlineCommand extends Command {
     public static final String COMMAND_STRING = Deadline.COMMAND_STRING;
     public static final CommandType COMMAND_TYPE = CommandType.DEADLINE;
 
     private final String description;
     private final LocalDate date;
 
+    /**
+     * Creates a DeadlineCommand that would add a Deadline with the supplied
+     * description and date to a TaskManager when executed.
+     *
+     * @param description Description of the Deadline to be added.
+     * @param date Date of the Deadline to be added.
+     */
     private DeadlineCommand(String description, LocalDate date) {
         this.description = description;
         this.date = date;
     }
 
+    /**
+     * Constructs a DeadlineCommand from a commandMap.
+     *
+     * @param commandMap CommandMap representing the instruction.
+     * @return DeadlineCommand object based on the commandMap.
+     * @throws DukeException When the user inputs an illegal instruction for the
+     * Deadline command.
+     */
     public static DeadlineCommand fromCommandMap(HashMap<String, List<String>> commandMap)
             throws DukeException {
         String description;
         LocalDate date;
 
+        assert Parser.extractCommandString(commandMap).equals(COMMAND_STRING)
+                : COMMAND_STRING + "CommandFlag does not match";
+
         // Validate description
         List<String> descriptionStrings = commandMap.get(COMMAND_STRING);
         if (descriptionStrings.isEmpty()) {
@@ -40,14 +62,20 @@ public static DeadlineCommand fromCommandMap(HashMap<String, List<String>> comma
             String dateString = dateStrings.get(0);
             date = LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE);
         } catch (NullPointerException e) {
-            throw new DukeException("Please provide an end date");
-        } catch (DateTimeParseException e) {
+            throw new DukeException("Please provide an end date using the \"/by\" flag");
+        } catch (IndexOutOfBoundsException | DateTimeParseException e) {
             throw new DukeException("Please input date in the form YYYY-MM-DD");
         }
 
         return new DeadlineCommand(description, date);
     }
 
+    /**
+     * Adds the specified Deadline Task to the supplied TaskManager.
+     *
+     * @param taskManager TaskManager object to add the Deadline Task to.
+     * @return String response of the action that was performed.
+     */
     @Override
     public String execute(TaskManager taskManager) {
         return taskManager.addTask(new Deadline(description, date));

src/main/java/command/DeleteCommand.java

@@ -2,21 +2,43 @@
 
 import task.TaskManager;
 import util.DukeException;
+import util.Parser;
 
 import java.util.HashMap;
 import java.util.List;
 
+/**
+ * Command to remove the specified Task from a TaskManger.
+ */
 public class DeleteCommand extends Command {
     public static final String COMMAND_STRING = "delete";
     public static final CommandType COMMAND_TYPE = CommandType.DELETE;
     private final int position;
 
+    /**
+     * Creates a DeleteCommand that would delete the task at the specified
+     * position in the TaskManager when executed.
+     *
+     * @param position The position / index of the task to be deleted.
+     */
     public DeleteCommand(int position) {
         this.position = position;
     }
 
+    /**
+     * Constructs a DeleteCommand from a commandMap.
+     *
+     * @param commandMap CommandMap representing the instruction.
+     * @return DeleteCommand object based on the commandMap.
+     * @throws DukeException When the user inputs an argument that cannot be parsed
+     * into a valid Integer position.
+     */
     public static DeleteCommand fromCommandMap(HashMap<String, List<String>> commandMap)
             throws DukeException {
+
+        assert Parser.extractCommandString(commandMap).equals(COMMAND_STRING)
+                : COMMAND_STRING + "CommandFlag does not match";
+
         try {
             List<String> descriptions = commandMap.get(COMMAND_STRING);
             String indexString = descriptions.get(0);
@@ -29,6 +51,14 @@ public static DeleteCommand fromCommandMap(HashMap<String, List<String>> command
         }
     }
 
+    /**
+     * Deletes the pre-specified task in the supplied TaskManager.
+     *
+     * @param taskManager TaskManager object to delete a Task from.
+     * @return String response of the deletion.
+     * @throws DukeException If the specified position does not exist within the
+     * supplied TaskManager.
+     */
     @Override
     public String execute(TaskManager taskManager) throws DukeException {
         return taskManager.deleteTask(position);

src/main/java/command/EventCommand.java

@@ -3,30 +3,52 @@
 import task.Event;
 import task.TaskManager;
 import util.DukeException;
+import util.Parser;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 import java.util.HashMap;
 import java.util.List;
 
+/**
+ * Command to add an Event Task to a TaskManager.
+ */
 public class EventCommand extends Command {
     public static final String COMMAND_STRING = "event";
     public static final CommandType COMMAND_TYPE = CommandType.EVENT;
 
     private final String description;
     private final LocalDate date;
 
+    /**
+     * Creates an EventCommand that would add a Event with the supplied
+     * description and date to a TaskManager when executed.
+     *
+     * @param description Description of the Event to be added.
+     * @param date Date of the Event to be added.
+     */
     private EventCommand(String description, LocalDate date) {
         this.description = description;
         this.date = date;
     }
 
+    /**
+     * Constructs an EventCommand from a commandMap.
+     *
+     * @param commandMap CommandMap representing the instruction.
+     * @return EventCommand object based on the commandMap.
+     * @throws DukeException When the user inputs an illegal instruction for the
+     * Event command.
+     */
     public static EventCommand fromCommandMap(HashMap<String, List<String>> commandMap)
             throws DukeException {
         String description;
         LocalDate date;
 
+        assert Parser.extractCommandString(commandMap).equals(COMMAND_STRING)
+                : COMMAND_STRING + "CommandFlag does not match";
+
         // Validate description
         List<String> descriptionStrings = commandMap.get(COMMAND_STRING);
         if (descriptionStrings.isEmpty()) {
@@ -40,14 +62,20 @@ public static EventCommand fromCommandMap(HashMap<String, List<String>> commandM
             String dateString = dateStrings.get(0);
             date = LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE);
         } catch (NullPointerException e) {
-            throw new DukeException("Please provide a date");
-        } catch (DateTimeParseException e) {
+            throw new DukeException("Please provide a date using the \"/at\" flag");
+        } catch (IndexOutOfBoundsException | DateTimeParseException e) {
             throw new DukeException("Please input date in the form YYYY-MM-DD");
         }
 
         return new EventCommand(description, date);
     }
 
+    /**
+     * Adds the specified Event Task to the supplied TaskManger.
+     *
+     * @param taskManager TaskManager object to add the Event Task to.
+     * @return String response of the action that was performed.
+     */
     @Override
     public String execute(TaskManager taskManager) {
         return taskManager.addTask(new Event(description, date));

src/main/java/command/FindCommand.java

@@ -4,23 +4,44 @@
 import task.TaskManager;
 import util.DukeException;
 import util.Formatter;
+import util.Parser;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+/**
+ * Command to search for keywords in the description of Tasks in a supplied
+ * TaskManager and return a list of the matching Tasks.
+ */
 public class FindCommand extends Command {
     public static final String COMMAND_STRING = "find";
     public static final CommandType COMMAND_TYPE = CommandType.FIND;
     private final List<String> keywords;
 
+    /**
+     * Creates a FindCommand that would return a String that lists all the Tasks
+     * whose descriptions match all the keywords.
+     *
+     * @param keywords List of keywords that must appear in the matching Tasks.
+     */
     private FindCommand(List<String> keywords) {
         this.keywords = keywords;
     }
 
+    /**
+     * Constructs a FindCommand from a commandMap.
+     *
+     * @param commandMap CommandMap representing the instruction.
+     * @return FindCommand object based on the commandMap.
+     * @throws DukeException When the user does not specify any search keywords.
+     */
     public static FindCommand fromCommandMap(HashMap<String, List<String>> commandMap)
             throws DukeException {
+        assert Parser.extractCommandString(commandMap).equals(COMMAND_STRING)
+                : COMMAND_STRING + "CommandFlag does not match";
+
         List<String> keywords = commandMap.get(COMMAND_STRING);
 
         if (keywords.isEmpty()) {
@@ -30,6 +51,13 @@ public static FindCommand fromCommandMap(HashMap<String, List<String>> commandMa
         return new FindCommand(keywords);
     }
 
+    /**
+     * Searches the supplied TaskManager for all Tasks whose descriptions contain
+     * all of the keywords.
+     *
+     * @param taskManager TaskManager object to search in.
+     * @return String that lists all the matching tasks.
+     */
     @Override
     public String execute(TaskManager taskManager) {
         StringBuilder output = new StringBuilder();
@@ -50,10 +78,19 @@ public String execute(TaskManager taskManager) {
                 .filter(taskPredicate)
                 .map(Task::toString)
                 .collect(Collectors.toList());
-        String listOfTasks = Formatter.formatList(filteredTaskStrings);
 
+        // If no tasks match the predicate, inform the user.
+        if (filteredTaskStrings.isEmpty()) {
+            String quotedKeywords = keywords.stream()
+                    .map(s -> "\"" + s + "\"")
+                    .collect(Collectors.joining(" + "));
+            return "No tasks match the keywords: \n" + quotedKeywords;
+        }
+
+        String listOfTasks = Formatter.formatList(filteredTaskStrings);
         output.append("Here are the tasks that match your search: ").append("\n");
         output.append(listOfTasks);
+
         return output.toString();
     }
 }