iP: Week 3

Here is the requirement:

[=====

Save the tasks on the hard disk automatically whenever the task list changes. Load the data from the hard disk when the chatbot starts up. You may hard-code the file name and relative path from the project root, e.g., ./data/duke.txt

The format of the file is up to you. Example:

T | 1 | read book
D | 0 | return book | June 6th
E | 0 | project meeting | Aug 6th 2-4pm
T | 1 | join sports club

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

=====]

For now, do a minimal implementation of the "happy path" for writing to the file. Reading from the file can be implemented later. Update tests and run /test-ui. At the end, run /present-changes-visually

Proceed to implementing the reading from the file, similar to the previous round.

In this round, enhance the code to handle all edge cases and possible errors.

Here are two additional requirements. Ensure the code meets them too.

...

The target: [=====

Gradually (i.e., in small steps) extract closely related code as classes.

• Minimal: Extract the following classes:
  • Ui: deals with interactions with the user
  • Storage: deals with loading tasks from the file and saving tasks in the file
  • Parser: deals with making sense of the user command
  • TaskList: contains the task list, e.g., it has operations to add/delete tasks in the list

For example, the code of the main class could look like this:

public class Duke {

    private Storage storage;
    private TaskList tasks;
    private Ui ui;

    public Duke(String filePath) {
        ui = new Ui();
        storage = new Storage(filePath);
        try {
            tasks = new TaskList(storage.load());
        } catch (DukeException e) {
            ui.showLoadingError();
            tasks = new TaskList();
        }
    }

    public void run() {
        //...
    }

    public static void main(String[] args) {
        new Duke("data/tasks.txt").run();
    }
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Your class names may differ from the ones given above. The design can differ too, as long as you can justify it as good OOP.

=====]

Let's do this iteratively. In each iteration, do the following steps:

1. Decide the next natural stand-alone increment that moves the code closer to the target.
2. Implement that increment.
3. Test it to ensure there are no regressions, using the /test-ui skill.
4. Commit the changes with a detailed commit message. You have my permission to commit in this repo.
5. Generate a visual diff using the /present-changes-visually skill. Also explain the rationale for the change and its pros and cons.
6. Briefly outline the next increment to be done in the next iteration. If there are no more increments worth doing, say so and stop.

Go ahead and do the first iteration.

Now, let's go for the stretch goal given below. Proceed in the same iterative fashion as before.

[=====

• Stretch goal: Consider extracting more classes, e.g., *Command classes (i.e., AddCommand, DeleteCommand, ExitCommand etc.) that inherit from an abstract Command class, so that you can write the main logic of the app as follows:

  public void run() {
      ui.showWelcome();
      boolean isExit = false;
      while (!isExit) {
          try {
              String fullCommand = ui.readCommand();
              ui.showLine(); // show the divider line ("_______")
              Command c = Parser.parse(fullCommand);
              c.execute(tasks, ui, storage);
              isExit = c.isExit();
          } catch (DukeException e) {
              ui.showError(e.getMessage());
          } finally {
              ui.showLine();
          }
      }
  }
  
      
  
      Copy
      
  
      
  
  
      
      
      
      
  
      Wrap Text
      
  
      
  
  
      
      
      

=====]

The requirement: Organize the classes into suitable Java packages. The src/main/java should be kept as the source root folder.

Suggest a suitable package structure for the classes in the project. Do not implement it yet.

How do I check if Gradle is working?

When I run my app in IDE, I face this error (see the screenshots I've attached). This happened after I added Gradle support to the project. How do I fix it?

Add a JUnit test to test one of the methods in the codebase. Choose a method that lends itself well to testing through JUnit. Include all reasonable test cases. Follow Gradle and JUnit conventions as to the file path and naming. Example:

• Class being tested seedu.duke.Todo: src\main\java\seedu\duke\Todo.java
• Test class seedu.duke.TodoTest: src\test\java\seedu\duke\TodoTest.java

If names of the test methods are long, you may resort to the following naming convention: featureUnderTest_testScenario_expectedBehavior()

e.g. sortList_emptyList_exceptionThrown() getMember_memberNotFound_nullReturned()

Add tests for all candidate methods that deserve tests in that class.

Test coverage target: Focus JUnit tests on the top ~50% highest-value methods (prioritizing complex, core, or critical business logic).

Go ahead and add more tests based on the above target.

Update the relevant AI documentation to reflect the test coverage target of 50%. Mention that JUnit tests need to be updated after each code change to comply with that target.

Create a project-specific skill named seedu-java-coding-standard based on rules given in https://se-education.org/guides/conventions/java/intermediate.html

Update your agent files to mandate following this for all code in this project.

Update the current code to follow it, where necessary.

Show me the changes using the /present-changes-visually skill.

Create a project-specific skill named seedu-git-standard based on rules given in https://se-education.org/guides/conventions/git.html

Update your agent files to mandate following this for all future commits.

Propose a commit message for the uncommitted Java code changes.

Create one commit for the Java code changes, and one commit for each standalone change to agent files.