A-CodeQuality

prerthan99 · prerthan99 · commit 7f251d2d214d · 2021-02-15T00:32:18.000+08:00
diff --git a/src/main/java/prerthan/duke/Duke.java b/src/main/java/prerthan/duke/Duke.java
@@ -1,11 +1,11 @@
 package prerthan.duke;
 
 import javafx.application.Platform;
+import prerthan.duke.exception.DukeEmptyDetailException;
 import prerthan.duke.exception.DukeInvalidArgumentException;
-import prerthan.duke.exception.DukeInvalidDateTimeException;
 import prerthan.duke.command.Command;
-import prerthan.duke.exception.DukeEmptyDetailException;
 import prerthan.duke.exception.DukeInvalidCommandException;
+import prerthan.duke.exception.DukeInvalidDateTimeException;
 import prerthan.duke.io.Input;
 import prerthan.duke.io.Output;
 import prerthan.duke.io.Storage;
@@ -79,8 +79,7 @@ public static void main(String[] args) {
         }
     }
 
-    public String getResponse(String input) {
-
-        return input;
+    public void getResponse(String input) {
+        
     }
 }
diff --git a/src/main/java/prerthan/duke/Main.java b/src/main/java/prerthan/duke/Main.java
@@ -8,7 +8,7 @@
 import prerthan.duke.ui.MainWindow;
 
 import java.io.IOException;
-//
+
 /**
  * Main
  */
diff --git a/src/main/java/prerthan/duke/command/AddCommand.java b/src/main/java/prerthan/duke/command/AddCommand.java
@@ -2,18 +2,17 @@
 
 import prerthan.duke.exception.DukeEmptyDetailException;
 import prerthan.duke.exception.DukeInvalidDateTimeException;
-import prerthan.duke.io.Output;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.Deadline;
-import prerthan.duke.task.Event;
 import prerthan.duke.task.TaskList;
 import prerthan.duke.task.Todo;
+import prerthan.duke.io.Output;
+import prerthan.duke.task.Event;
 
 /**
  * AddCommand
  */
 public class AddCommand extends Command {
-    private CommandName commandName;
 
     public AddCommand(String detail, CommandName commandName) {
         super(detail);
diff --git a/src/main/java/prerthan/duke/command/ByeCommand.java b/src/main/java/prerthan/duke/command/ByeCommand.java
@@ -1,10 +1,10 @@
 package prerthan.duke.command;
 
-import prerthan.duke.exception.DukeInvalidArgumentException;
 import prerthan.duke.Duke;
-import prerthan.duke.io.Output;
+import prerthan.duke.exception.DukeInvalidArgumentException;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.TaskList;
+import prerthan.duke.io.Output;
 
 /**
  * ByeCommand
@@ -21,7 +21,7 @@ public ByeCommand(String[] argumentTokens) throws DukeInvalidArgumentException {
     }
 
     @Override public void execute(TaskList tasks, Storage storage, Output output) {
-        Duke.exit();
+        Duke.output.sayGoodBye();
     }
 
     @Override public boolean willTerminate() {
diff --git a/src/main/java/prerthan/duke/command/Command.java b/src/main/java/prerthan/duke/command/Command.java
@@ -1,10 +1,10 @@
 package prerthan.duke.command;
 
-import prerthan.duke.exception.DukeInvalidDateTimeException;
 import prerthan.duke.exception.DukeEmptyDetailException;
-import prerthan.duke.io.Output;
+import prerthan.duke.exception.DukeInvalidDateTimeException;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.TaskList;
+import prerthan.duke.io.Output;
 
 /**
  * Models a possible user command to the Duke program.
diff --git a/src/main/java/prerthan/duke/command/DeleteCommand.java b/src/main/java/prerthan/duke/command/DeleteCommand.java
@@ -1,9 +1,9 @@
 package prerthan.duke.command;
 
 import prerthan.duke.exception.DukeInvalidArgumentException;
-import prerthan.duke.io.Output;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.TaskList;
+import prerthan.duke.io.Output;
 
 /**
  * A user
diff --git a/src/main/java/prerthan/duke/command/DoneCommand.java b/src/main/java/prerthan/duke/command/DoneCommand.java
@@ -1,10 +1,10 @@
 package prerthan.duke.command;
 
 import prerthan.duke.exception.DukeInvalidArgumentException;
-import prerthan.duke.task.Task;
-import prerthan.duke.io.Output;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.TaskList;
+import prerthan.duke.io.Output;
+import prerthan.duke.task.Task;
 
 /**
  * DoneCommand
diff --git a/src/main/java/prerthan/duke/command/FindCommand.java b/src/main/java/prerthan/duke/command/FindCommand.java
@@ -4,10 +4,10 @@
 import prerthan.duke.exception.DukeEmptyDetailException;
 import prerthan.duke.exception.DukeInvalidArgumentException;
 import prerthan.duke.exception.DukeInvalidDateTimeException;
+import prerthan.duke.io.Storage;
+import prerthan.duke.task.TaskList;
 import prerthan.duke.io.Output;
 import prerthan.duke.task.Task;
-import prerthan.duke.task.TaskList;
-import prerthan.duke.io.Storage;
 
 import java.util.stream.Stream;
 
diff --git a/src/main/java/prerthan/duke/command/ListCommand.java b/src/main/java/prerthan/duke/command/ListCommand.java
@@ -1,10 +1,10 @@
 package prerthan.duke.command;
 
 import prerthan.duke.exception.DukeInvalidArgumentException;
-import prerthan.duke.exception.DukeInvalidCommandException;
-import prerthan.duke.io.Output;
 import prerthan.duke.io.Storage;
 import prerthan.duke.task.TaskList;
+import prerthan.duke.exception.DukeInvalidCommandException;
+import prerthan.duke.io.Output;
 
 /**
  * ListCommand
diff --git a/src/main/java/prerthan/duke/io/Input.java b/src/main/java/prerthan/duke/io/Input.java
@@ -2,8 +2,8 @@
 
 import prerthan.duke.command.*;
 import prerthan.duke.exception.DukeInvalidArgumentException;
-import prerthan.duke.command.*;
 import prerthan.duke.exception.DukeInvalidCommandException;
+import prerthan.duke.command.*;
 
 import java.io.BufferedReader;
 import java.io.IOException;
diff --git a/src/main/java/prerthan/duke/io/Storage.java b/src/main/java/prerthan/duke/io/Storage.java
@@ -22,6 +22,12 @@ public class Storage {
 
     private BufferedWriter writer;
 
+    /**
+     * Creates a new {@link Storage} object for working with the data file as saved by Duke,
+     * using the provided {@code filePath}.
+     *
+     * @param filePath a comma-separated list of the file directory structure
+     */
     public Storage(String... filePath) {
         this.taskFile = Paths.get(".", filePath).normalize().toAbsolutePath();
 
@@ -42,7 +48,7 @@ public Storage(String... filePath) {
     }
 
     /**
-     * Returns a possible {@link Task} after decoding {@code line}
+     * Returns a possible {@link Task} after decoding {@code line}.
      *
      * @param line A line from the file
      * @return A possible task; returns {@link Optional#empty()} if line cannot be decoded
@@ -57,12 +63,12 @@ static Optional<Task> decodeLine(String line) {
             case "D":
                 return tokens.length == 4 ? Optional
                     .of(new Deadline(tokens[2], Boolean.parseBoolean(tokens[1]),
-                                     DateParser.parseDateTimeString(tokens[3]))) : Optional.empty();
+                                     DateParser.decodeString(tokens[3]))) : Optional.empty();
             case "E":
                 return tokens.length == 5 ? Optional
                     .of(new Event(tokens[2], Boolean.parseBoolean(tokens[1]),
-                                  DateParser.parseDateTimeString(tokens[3]),
-                                  DateParser.parseDateTimeString(tokens[4]))) : Optional.empty();
+                                  DateParser.decodeString(tokens[3]),
+                                  DateParser.decodeString(tokens[4]))) : Optional.empty();
             default:
                 return Optional.empty();
             }
@@ -85,13 +91,14 @@ public void appendTaskToFile(Task task) {
             writer.flush();
         }
         catch (IOException e) {
-            e.printStackTrace();
+            Output.ioException();
         }
     }
 
     /**
      * Returns a {@link TaskList}, parsed from the specified file associated with
      * this {@link Storage} object.
+
      */
     public TaskList loadFromFile() {
         try {
@@ -100,7 +107,8 @@ public TaskList loadFromFile() {
                      .map(Optional::get).collect(Collectors.toList()));
         }
         catch (IOException e) {
-            Duke.output.sayError(e);
+            Output.ioException();
+            Duke.output.say("File could not be read; creating new list.");
             return new TaskList();
         }
     }
diff --git a/src/main/java/prerthan/duke/parse/DateParser.java b/src/main/java/prerthan/duke/parse/DateParser.java
@@ -12,7 +12,8 @@
 import java.util.Optional;
 
 /**
- * A utility class to parse {@link String}s into {@link ZonedDateTime} objects, and format
+ * A utility class to parse {@link String}s into {@link ZonedDateTime} objects,
+ * and format
  * vice-versa, useable by the Duke program.
  */
 public final class DateParser {
@@ -39,25 +40,30 @@ public final class DateParser {
     private static final ZonedDateTime now = ZonedDateTime.now();
 
     /**
-     * Returns a {@link ZonedDateTime} after parsing {@code dateTimeString}.
+     * Returns a {@link ZonedDateTime} after parsing
+     * {@code dateTimeString}.
      *
      * @param dateTimeString the {@link String} to be parsed
      * @return the date-time object after parsing the string
-     * @throws DukeInvalidDateTimeException if {@code dateTimeString} cannot be parsed
+     * @throws DukeInvalidDateTimeException if {@code dateTimeString} cannot be
+     *                                      parsed
      */
     public static ZonedDateTime parseDateTimeString(String dateTimeString)
         throws DukeInvalidDateTimeException {
-        ZonedDateTime returnable = now;
+        Optional<ZonedDateTime> returnable = Optional.empty();
 
         for (DateTimeFormatter formatter : FORMATTERS) {
-            returnable = parseStringWithFormatter(dateTimeString, formatter);
+            returnable = parseStringWithFormatter(dateTimeString, formatter, returnable);
         }
-        return returnable;
+        return returnable.orElseThrow(
+            () -> new DukeInvalidDateTimeException(DateParser.class.getName(), dateTimeString));
     }
 
     /**
-     * Returns a {@link String} from the provided {@code dateTimeGroup}, as specified by a
-     * formatter in this class. The formatter is provided with the pattern: {@code "EEEE dd MMMM
+     * Returns a {@link String} from the provided {@code dateTimeGroup}, as
+     * specified by a
+     * formatter in this class. The formatter is provided with the pattern:
+     * {@code "EEEE dd MMMM
      * YYYY hh:mm a v"}.
      *
      * @param dateTimeGroup the {@link ZonedDateTime} to be formatted
@@ -68,46 +74,52 @@ public static String formatZonedDateTime(ZonedDateTime dateTimeGroup) {
     }
 
     /**
-     * @param dateTimeGroup
-     * @return
+     * Returns an encoded {@link String} to be written to the data file, by
+     * formatting {@code dateTimeGroup}.
+     *
+     * @param dateTimeGroup The {@link ZonedDateTime} date-time-group to be
+     *                      formatted
+     * @return The formatted string
      */
     public static String encodeZonedDateTime(ZonedDateTime dateTimeGroup) {
         return DateTimeFormatter.ISO_INSTANT.format(dateTimeGroup);
     }
 
     /**
-     * @param encoded
-     * @return
+     * Returns a decoded {@link ZonedDateTime} from the given {@link String}
+     * {@code input}, using the {@link DateTimeFormatter#ISO_INSTANT} parser.
+     *
+     * @param encoded A previously-encoded {@link String}, usually from the data
+     *                file
+     * @return the {@link ZonedDateTime} instant corresponding to the parsed string
      */
     public static ZonedDateTime decodeString(String encoded) {
-        return DateTimeFormatter.ISO_INSTANT.parse(encoded, ZonedDateTime::from);
+        return DateTimeFormatter.ISO_ZONED_DATE_TIME.parse(encoded, ZonedDateTime::from);
     }
 
-    /**
-     * @param string
-     * @param formatter
-     * @return
-     * @throws DukeInvalidDateTimeException
-     */
-    private static ZonedDateTime parseStringWithFormatter(String string,
-                                                          DateTimeFormatter formatter)
+    private static Optional<ZonedDateTime> parseStringWithFormatter(String string,
+                                                                    DateTimeFormatter formatter,
+                                                                    Optional<ZonedDateTime> possibleZDT)
         throws DukeInvalidDateTimeException {
         Optional<TemporalAccessor> possiblyParsed;
 
-        ZonedDateTime returnable = ZonedDateTime.ofInstant(now.toInstant(), now.getZone());
         try {
             possiblyParsed = Optional.of(formatter.parse(string));
         }
         catch (DateTimeParseException e) {
             possiblyParsed = Optional.empty();
         }
         if (possiblyParsed.isPresent()) {
+            ZonedDateTime returnable = possibleZDT.orElse(now);
             TemporalAccessor parsed = possiblyParsed.get();
             for (TemporalField field : formatter.getResolverFields()) {
                 returnable = returnable
                     .with(field, parsed.isSupported(field) ? parsed.get(field) : now.get(field));
             }
+            return Optional.of(returnable);
+        } else {
+            return possibleZDT;
         }
-        return returnable;
+
     }
 }
diff --git a/src/main/java/prerthan/duke/task/Deadline.java b/src/main/java/prerthan/duke/task/Deadline.java
@@ -1,8 +1,8 @@
 package prerthan.duke.task;
 
-import prerthan.duke.exception.DukeInvalidDateTimeException;
-import prerthan.duke.parse.DateParser;
 import prerthan.duke.exception.DukeEmptyDetailException;
+import prerthan.duke.parse.DateParser;
+import prerthan.duke.exception.DukeInvalidDateTimeException;
 
 import java.time.ZonedDateTime;
 
@@ -13,6 +13,8 @@ public class Deadline extends Task {
     private ZonedDateTime by;
 
     /**
+     * Creates a new {@link Deadline} with the provided {@code detail}, {@code isComplete} and
+     *
      * @param detail
      * @param by
      * @throws DukeEmptyDetailException
@@ -21,6 +23,7 @@ public Deadline(String detail, boolean isComplete, ZonedDateTime by)
         throws DukeEmptyDetailException {
         super(detail, isComplete);
         this.by = by;
+        assert this.detail != null || this.by != null || !this.isComplete;
     }
 
     /**
@@ -48,6 +51,6 @@ public Deadline(String detail, String by)
     @Override public String encode() {
         return String
             .format("%c,%d,%s,%s", this.getTaskTypeIcon(), this.isComplete ? 1 : 0, this.detail,
-                    DateParser.formatZonedDateTime(this.by));
+                    DateParser.encodeZonedDateTime(this.by));
     }
 }
diff --git a/src/main/java/prerthan/duke/task/Event.java b/src/main/java/prerthan/duke/task/Event.java
diff --git a/src/main/java/prerthan/duke/task/Task.java b/src/main/java/prerthan/duke/task/Task.java
diff --git a/src/main/java/prerthan/duke/task/TaskList.java b/src/main/java/prerthan/duke/task/TaskList.java
diff --git a/src/main/java/prerthan/duke/task/Todo.java b/src/main/java/prerthan/duke/task/Todo.java

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`package prerthan.duke;`
`2`	`2`
`3`	`3`	`import javafx.application.Platform;`
	`4`	`+import prerthan.duke.exception.DukeEmptyDetailException;`
`4`	`5`	`import prerthan.duke.exception.DukeInvalidArgumentException;`
`5`		`-import prerthan.duke.exception.DukeInvalidDateTimeException;`
`6`	`6`	`import prerthan.duke.command.Command;`
`7`		`-import prerthan.duke.exception.DukeEmptyDetailException;`
`8`	`7`	`import prerthan.duke.exception.DukeInvalidCommandException;`
	`8`	`+import prerthan.duke.exception.DukeInvalidDateTimeException;`
`9`	`9`	`import prerthan.duke.io.Input;`
`10`	`10`	`import prerthan.duke.io.Output;`
`11`	`11`	`import prerthan.duke.io.Storage;`
`@@ -79,8 +79,7 @@ public static void main(String[] args) {`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`- public String getResponse(String input) {`
`83`		`-`
`84`		`- return input;`
	`82`	`+ public void getResponse(String input) {`
	`83`	`+`
`85`	`84`	`}`
`86`	`85`	`}`