[CS2113-W12-4] Java Ninja

META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: seedu.javaninja.JavaNinja
+

README.md

@@ -1,6 +1,6 @@
-# Duke project template
+# Java Ninja
 
-This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
+Java Ninja is a command-line interface (CLI) learning tool focused on helping beginner programmers enhance their understanding of fundamental programming concepts. This tool provides different modes of assessments with various difficulty levels as you progress.
 
 ## Setting up in Intellij
 
@@ -10,19 +10,7 @@ Prerequisites: JDK 17 (use the exact version), update Intellij to the most recen
 1. **Import the project _as a Gradle project_**, as described [here](https://se-education.org/guides/tutorials/intellijImportGradleProject.html).
 1. **Verify the setup**: After the importing is complete, locate the `src/main/java/seedu/duke/Duke.java` file, right-click it, and choose `Run Duke.main()`. If the setup is correct, you should see something like the below:
    ```
-   > Task :compileJava
-   > Task :processResources NO-SOURCE
-   > Task :classes
-
-   > Task :Duke.main()
-   Hello from
-    ____        _        
-   |  _ \ _   _| | _____ 
-   | | | | | | | |/ / _ \
-   | |_| | |_| |   <  __/
-   |____/ \__,_|_|\_\___|
-
-   What is your name?
+
    ```
    Type some word and press enter to let the execution proceed to the end.
 

build.gradle

@@ -29,18 +29,19 @@ test {
 }
 
 application {
-    mainClass.set("seedu.duke.Duke")
+    mainClass.set("seedu.javaninja.JavaNinja")
 }
 
 shadowJar {
-    archiveBaseName.set("duke")
+    archiveBaseName.set("javaninja")
     archiveClassifier.set("")
 }
 
 checkstyle {
     toolVersion = '10.2'
 }
 
-run{
+run {
     standardInput = System.in
-}
+    enableAssertions = true
+}

data/Questions.txt

@@ -0,0 +1,34 @@
+Loops | TrueFalse | Java is a programming language. | true
+Loops | TrueFalse | A while loop will execute at least once. | false
+Loops | TrueFalse | A for loop is used when the number of iterations is known. | true
+Loops | TrueFalse | A do-while loop will execute its body before checking the condition. | true
+Loops | TrueFalse | A for-each loop is primarily used for iterating over collections. | true
+Loops | TrueFalse | A while loop is best used when the number of iterations is known. | false
+Loops | TrueFalse | A break statement can be used to exit a loop early. | true
+Loops | TrueFalse | A continue statement skips the current iteration of a loop. | true
+Loops | TrueFalse | A do-while loop will never execute if the condition is false initially. | false
+Loops | TrueFalse | Infinite loops can only be created using a while loop. | false
+Loops | TrueFalse | You can nest loops inside one another in Java. | true
+Loops | Mcq | Which of the following is a loop structure in Java? | b | a) if-else | b) for | c) switch | d) try-catch
+Loops | Mcq | Which loop guarantees at least one iteration? | a | a) do-while | b) for | c) while | d) for-each
+Loops | Mcq | Which keyword is used to exit a loop early? | c | a) continue | b) return | c) break | d) stop
+Loops | Mcq | Which type of loop is used when the number of iterations is fixed? | b | a) while | b) for | c) do-while | d) foreach
+Loops | Mcq | What is the correct syntax for a for loop in Java? | a | a) for (int i = 0; i < 10; i++) | b) for (i = 0; i < 10; i++) | c) for int i : range(10) | d) foreach (int i in range(10))
+Loops | Mcq | Which of the following loop types can be infinite? | a | a) while | b) do-while | c) for | d) All of the above
+Loops | Mcq | Which of the following loops is suitable for iterating over a collection? | d | a) while | b) do-while | c) simple for | d) for-each
+Loops | Mcq | What happens if the condition in a for loop is omitted? | c | a) Compilation error | b) Infinite loop | c) The loop continues until it is explicitly broken | d) None of the above
+Loops | Mcq | Which keyword can be used to skip to the next iteration of a loop? | a | a) continue | b) skip | c) next | d) pass
+Loops | Mcq | What is the output of an infinite while loop without a condition? | b | a) Compilation error | b) Loop continues indefinitely | c) Loop runs once | d) None of the above
+Loops | FillInTheBlank | The keyword used to declare a method that does not return a value is `____`. | void
+Loops | FillInTheBlank | The `____` keyword is used to create a new object in Java. | new
+Loops | FillInTheBlank | In Java, the method that runs when the program starts is called `____`. | main
+Loops | FillInTheBlank | The access modifier `____` allows visibility within the same package and subclasses. | protected
+Loops | FillInTheBlank | The `____` statement is used to terminate the execution of a method and return a value. | return
+Loops | FillInTheBlank | To compare two strings in Java, you use the `____` method. | equals
+Loops | FillInTheBlank | In Java, arrays have a fixed `____` once they are initialized. | size
+Loops | FillInTheBlank | A `____` is a block of code that can be called with a set of arguments and performs a specific task. | method
+Loops | FillInTheBlank | The `____` keyword is used to inherit properties and methods from another class. | extends
+Loops | FillInTheBlank | The keyword `____` is used to implement an interface in a class. | implements
+Loops | FillInTheBlank | The keyword used to define a class is `____`. | class
+Loops | FillInTheBlank | A constructor in Java is used to create an instance of a `____`. | object
+Loops | FillInTheBlank | The keyword used to declare a constant in Java is ___ | final

data/results.txt

@@ -0,0 +1,2 @@
+Score: 8%, Comment: Better luck next time!
+Score: 23%, Comment: Better luck next time!

docs/AboutUs.md

@@ -1,9 +1,11 @@
 # About us
 
-Display | Name | Github Profile | Portfolio 
---------|:----:|:--------------:|:---------:
-![](https://via.placeholder.com/100.png?text=Photo) | John Doe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Joe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Ron John | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | John Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+
+Display |     Name      | Github Profile | Portfolio 
+--------|:-------------:|:--------------:|:---------:
+![](https://via.placeholder.com/100.png?text=Photo) |    Naveen     | [Github](https://github.com/naveen42x) | [Portfolio](docs/team/naveen42x.md)
+![](https://via.placeholder.com/100.png?text=Photo) | Zhang Zhitong | [Github](https://github.com/Zhang-Zhitong) | [Portfolio](docs/team/ZhangZhitong.md)
+![](https://via.placeholder.com/100.png?text=Photo) |   Shaun Goh   | [Github](https://github.com/shaunngoh) | [Portfolio](docs/team/shaunngoh.md)
+![](https://via.placeholder.com/100.png?text=Photo) |   Wang Yubo   | [Github](https://github.com/YubotKwng) | [Portfolio](docs/team/yubotkwng.md)
+![](https://via.placeholder.com/100.png?text=Photo) | Jinlin Wang | [Github](https://github.com/Lucky-Yuan00) | [Portfolio](docs/team/johndoe.md)
+

docs/DeveloperGuide.md

@@ -1,22 +1,145 @@
-# Developer Guide
+# JavaNinja Developer Guide
+Java Ninja is a command-line interface (CLI) learning tool focused on helping beginner programmers enhance their understanding of fundamental programming concepts.
+
+- [Design & implementation](#design-&-implementation)
+- [Product scope](#product-scope)
+    - [Target user profile](#target-user-profile)
+    - [Value proposition](#value-proposition)
+- [User Stories](#user-stories)
+- [Non-Functional Requirements](#non-Functional-Requirements)
+- [Glossary](#Glossary)
+- [Instructions for manual testing](#Instructions-for-manual-testing)
 
 ## Acknowledgements
 
 {list here sources of all reused/adapted ideas, code, documentation, and third-party libraries -- include links to the original source as well}
+- [Apache Commons Lang Library](https://commons.apache.org/proper/commons-lang/) - Used for string utilities.
+- [JUnit 5](https://junit.org/junit5/) - Used for testing.
+- Code adapted from [AddressBook-Level3](https://github.com/se-edu/addressbook-level3).
+
+JavaNinja uses the following tools for development:
+- JUnit - Used for testing.
+- Gradle - Used for build automation.
 
 ## Design & implementation
+
+### Design 
 
-{Describe the design and implementation of the product. Use UML diagrams and short code snippets where applicable.}
+#### Architecture 
+
+Main components of the architecture:
+
+`Main` (consisting of class `JavaNinja`) is in charge of the app launch and shut down. 
+1. At app launch, it initialises the components in the correct order and connects them with each other
+2. At shut down, it shuts down the other components and invokes cleanup methods 
+
+The bulk of the app's work is done by the respective components: 
+1. `Cli`: It handles the user interface of the app 
+2. `Parser`: The command executor 
+3. `QuizManager`: Holds the data of the App in memory
+4. `Storage`: Reads data from, and writes data to, the hard disk.
+
+`Commons` represent a collection of classes used by other components.
+
+How the architecture components interact with each other: 
+
+The Sequence Diagram below shows how the components interact with each other for the scenario where the user issues the command `add Flashcard /q what's 2+3 /a 5`
+
+![image](https://github.com/user-attachments/assets/1dd443de-b538-4fb8-b4d1-3bff4643b3dd)
+
+
+### True/False Feature Implementation
+
+The `TrueFalse` class is responsible for handling true/false questions within the quiz application. This section describes its design, implementation details, and the rationale behind design choices.
+
+#### Feature Overview
+The `TrueFalse` class represents a true/false question. It stores the question text and the correct answer as a boolean. Additionally, it includes methods to validate user answers and display answer options.
+
+#### Implementation Details
+
+1. **Attributes**:
+   - `boolean correctAnswer`: Stores the correct answer for the question.
+
+2. **Constructor**:
+   - `TrueFalse(String questionText, boolean correctAnswer)`:
+     Initializes the question text and the correct answer. The constructor checks that `questionText` is non-null and non-empty, ensuring a valid question is always provided.
+
+3. **Methods**:
+   - `checkAnswer(String userAnswer)`:
+     This method converts the user's input (`"true"` or `"false"`) into a boolean and compares it to the correct answer. It throws an `IllegalArgumentException` for invalid inputs, ensuring only `"true"` or `"false"` strings are accepted.
+   - `printOptions()`:
+     Displays answer choices ("1. True" and "2. False") for the user. This makes it clear what options are available for true/false questions.
+   - `toString()`:
+     Returns a string representation of the question with a "(True/False)" label to indicate its type.
+
+#### Design Rationale
+
+- **Boolean Storage for Correct Answer**: Storing the answer as a boolean simplifies the process of validating the user’s response since the comparison is a straightforward boolean check.
+- **Input Validation in `checkAnswer`**: This method ensures only `"true"` or `"false"` strings are accepted as valid answers, which prevents user input errors.
+- **Assertion Usage**: Assertions check that the question text and user answer are valid. This adds an additional layer of error handling during development.
+
+#### Alternative Considerations
 
+An alternative approach considered was to store `correctAnswer` as a `String` (`"true"` or `"false"`), which would simplify displaying it as text but would complicate validation. Using `boolean` was chosen for its simplicity and efficiency in logic checks.
+
+#### UML Class Diagram
+
+![TrueFalse Class Diagram](https://github.com/Lucky-Yuan00/tp/blob/jinlin-dev/docs/UML/TrueFalseClassDiagram.png?raw=true)
+
+The class diagram above shows the structure of the `TrueFalse` class, including its attributes and methods, and its inheritance relationship with the `Question` superclass.
+
+### Topic Class Implementation
+The `Topic` class is responsible for organizing questions under specific programming topics in the quiz application. It allows for modular storage of questions, making it easy for users to select topics and for developers to manage quiz content.
+
+#### **Feature Overview**
+The `Topic` class encapsulates a programming topic along with its related questions. It helps in grouping relevant questions, enabling quizzes to be topic-based, and provides essential methods to add and access questions within each topic.
+
+#### **Implementation Details**
+
+1. **Attributes**:
+    - `String name`: Stores the name of the topic.
+    - `List<Question> questions`: Holds a list of questions related to this topic.
+
+2. **Constructor**:
+    - `Topic(String name)`:  
+      Initializes the topic with a specified name and creates an empty list to hold its questions. Ensures that the `name` is non-null to prevent invalid topics.
+
+3. **Methods**:
+    - `addQuestion(Question question)`:  
+      Adds a `Question` object to the topic’s question list.
+    - `List<Question> getQuestions()`:  
+      Returns the list of questions under the topic.
+    - `String getName()`:  
+      Returns the name of the topic as a string.
+
+#### **Design Rationale**
+
+- **Encapsulation**: Storing questions inside a `Topic` object allows better separation of concerns and makes the quiz system more modular and extendable.
+- **Modularity for Scalability**: Organizing questions by topics makes the quiz system scalable, as more topics and questions can be easily added.
+- **Single Responsibility Principle (SRP)**: The `Topic` class focuses only on managing a single topic and its related questions, adhering to SRP.
+
+#### **Alternative Considerations**
+
+1. **Global List for Questions**:
+    - *Drawback*: Having a global list would make it harder to categorize questions logically and efficiently.
+
+2. **Direct Integration into QuizManager**:
+    - *Drawback*: This would tightly couple topic management with quiz functionality, making the code harder to maintain and less reusable.
+
+#### UML Class Diagram
+Below is the class diagram for the `Topic` class, illustrating its attributes and methods.
+![Topic Class Diagram](https://github.com/naveen42x/tp/blob/dg/docs/UML/TopicClasDiagram.png?raw=true)
+
+{Describe the design and implementation of the product. Use UML diagrams and short code snippets where applicable.}
 
 ## Product scope
 ### Target user profile
 
-{Describe the target user profile}
+Beginner programmers looking to improve their proficiency in Java and command-line skills.
 
 ### Value proposition
 
-{Describe the value proposition: what problem does it solve?}
+This tool will offer an interactive learning experience through a series of tasks and challenges designed to deepen users' understanding and proficiency in both command-line operations and Java language.
 
 ## User Stories
 
@@ -27,7 +150,10 @@
 
 ## Non-Functional Requirements
 
-{Give non-functional requirements}
+1. Technical Requirements: Any mainstream OS, i.e. Windows, macOS or Linux, with Java 17 installed.
+2. Project Scope Constraints: The application should only be used for practice and reviewing score progress
+3. Project Scope Constraints: Data storage is only to be performed locally.
+4. Quality Requirements: The application should be able to be used effectively by a novice with little experience with CLIs.
 
 ## Glossary
 
@@ -36,3 +162,9 @@
 ## Instructions for manual testing
 
 {Give instructions on how to do a manual product testing e.g., how to load sample data to be used for testing}
+
+### Manual Testing
+View the [User Guide](https://AY2425S1-CS2113-W12-4.github.io/tp/UserGuide.html) for the full list of UI commands and their related use case and expected outcomes.
+
+### JUnit Testing
+JUnit tests are written in the subdirectory `test` and serve to test key methods part of the application.

docs/UML/TrueFalseClassDiagram.puml

@@ -0,0 +1,20 @@
+@startuml
+class Question {
+    - text : String
+    + Question(String text)
+    + getText() : String
+    + checkAnswer(String userAnswer) : boolean
+    + printOptions() : void
+    + toString() : String
+}
+
+class TrueFalse {
+    - correctAnswer : boolean
+    + TrueFalse(String questionText, boolean correctAnswer)
+    + checkAnswer(String userAnswer) : boolean
+    + printOptions() : void
+    + toString() : String
+}
+
+TrueFalse --|> Question : extends
+@enduml