Added Project

Author: Al3xramirez

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.github/workflows/maven-ci.yml

@@ -0,0 +1,38 @@
+# .github/workflows/maven-ci.yml
+name: Java CI with Maven
+
+on:
+  push:
+    branches: [ "main", "dev" ]
+  pull_request:
+    branches: [ "main", "dev" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: maven
+
+      - name: Build, test and generate coverage
+        run: mvn -B test jacoco:report --file pom.xml
+
+      - name: Upload JaCoCo HTML report
+        uses: actions/upload-artifact@v4
+        with:
+          name: jacoco-html
+          path: target/site/jacoco/
+
+      - name: Upload JaCoCo exec data
+        uses: actions/upload-artifact@v4
+        with:
+          name: jacoco-exec
+          path: target/jacoco.exec

.gitignore

@@ -0,0 +1,20 @@
+# IntelliJ project files
+.idea/
+*.iml
+*.iws
+out/
+*.class
+
+# Build tools
+target/
+build/
+.gradle/
+.mvn/
+
+# OS artifacts
+.DS_Store
+Thumbs.db
+
+# Logs and temp
+*.log
+*.tmp

README.md

@@ -0,0 +1,244 @@
+# UML Manager (CLI & GUI)
+This **UML Manager** is an application that allows users to create and manage class definitions, fields, methods, parameters, and relationships between classes.
+It provides a simple way to review and model class structures and their associations with each other. You can run it either in **GUI mode** or **CLI mode**.
+
+## How to Run the Program 
+
+### 1. Make sure you have Java installed
+You need Java installed on your computer. If you are not sure, open a terminal and type:
+
+`java -version`
+
+If you see a version number, Java is installed. If not, you will need to install Java first.
+
+---
+
+### 2. Download and unzip the application
+- Click the "`Sprint4`" on the **Releases** section
+- Click on the "`Sprint4.Zip`" to start your download
+- Once you have downloaded, Extract(Unzip) the file
+
+---
+
+### 3. Open the Terminal or Command Prompt
+**OPTION 1**
+- **Windows:**
+    1. After you've unzipped, click on that folder, inside there will be a file called "target". Right click it (Make sure the file is selected), and press "`Open in Terminal`"
+
+     That will open the file in the terminal directory where it lives in.
+
+**OPTION 2**
+- **Windows:**  
+  1. Press `Win + R`, type `cmd`, and press Enter.
+- **Mac/Linux:**  
+  Open your terminal application.
+
+Navigate to the folder where you unzipped the files:
+
+`cd path/to/unzipped/folder`
+
+Example:
+
+`cd /Users/alexr/Downloads/UMLManager`
+
+---
+
+### 4. Run the Program
+
+There are two ways to run the program currently. 
+
+- **GUI Mode (default):**
+
+ In your terminal, copy and paste this ->  `java -jar 404App-1.0-SNAPSHOT-jar-with-dependencies.jar` on the command line.
+
+ This will start the GUI
+
+- **CLI Mode:**  
+
+ In your terminal, copy and past this ->  `java -jar 404App-1.0-SNAPSHOT-jar-with-dependencies.jar --cli` on the command line.
+
+ This will start the CLI
+
+### 5. What You Should See
+
+- **CLI Mode:**
+
+<img width="700" height="292" alt="image" src="https://github.com/user-attachments/assets/654a9686-c2b7-4d96-b021-303ee90ed0f3" />
+
+
+- **GUI Mode:**  
+<img width="500" height="782" alt="image" src="https://github.com/user-attachments/assets/0c33a157-5585-406e-ab22-0458a4ee91a7" />
+
+---
+
+## How To Use
+
+### - CLI
+
+1. The CLI is very self explanitory, when you type 'help' in the command line you'll see all avalable commands
+
+ <img width="800" height="1013" alt="image" src="https://github.com/user-attachments/assets/cc8db91f-1275-4bac-b740-28875575673c" />
+
+2. When you begin, you'll have to add a class first (These commands are case sensitive so be sure to look at how they are formatted).
+  Youll be prompted to type the class name
+  
+<img width="1917" height="73" alt="image" src="https://github.com/user-attachments/assets/528e3cca-c004-48cd-bb22-1dd42e4e2131" />
+
+3. Once that is complete you are free to add parameters, methods, fields, and relationships
+
+<img width="1900" height="543" alt="image" src="https://github.com/user-attachments/assets/dbf36493-9ceb-438d-b953-1b6ab6b4ffb9" />
+
+4. To add a relationship, you will need two classes minimum, I mean,  thats the whole point ;).
+   You will pe prompted to add a 'Source Class' and a 'Target Class' and the type of relationship.
+
+ <img width="1918" height="231" alt="image" src="https://github.com/user-attachments/assets/09e974a6-fad7-4296-baf4-c6eebeb783fb" />
+
+*Note: you might find that you'll get a '?' on the 'Relationship added' line, that simply means your terminal does not use UTF-8 ecoding unfortunately*
+
+5. To see the Classes you have listed simply type listClasses on the command line.
+
+   
+<img width="1918" height="303" alt="image" src="https://github.com/user-attachments/assets/346ca0ef-9c22-40ee-b9a2-ba77e04cb4a1" />
+
+6. To make typing more simple and efficient we also have autoimplementation, for example if you want to add a relationship you can begin
+   to type 'addR-' and then press [TAB] to autocomplete the rest, you can do this for fields, methods, CLI command, and parameter names!
+
+
+<img width="1918" height="66" alt="image" src="https://github.com/user-attachments/assets/2443a3ab-fcf8-4cda-a6c2-92a9fdf532db" />
+
+---
+
+## Available Commands for CLI
+
+### Project / Save Commands
+- `new`
+
+  Clears the current project and starts a new blank project.
+
+- `load`  
+  Loads a previously saved project from a JSON file.
+
+- `save`  
+  Saves the current project to the last used save path. If no save exists, prompts for a filename.
+
+- `saveAs`  
+  Prompts for a filename and saves the current project under that name.
+
+---
+
+### Class Commands
+- `addClass`
+  Creates a new class.
+
+- `deleteClass`  
+  Deletes an existing class.
+
+- `renameClass`  
+  Renames a class.
+
+- `listClasses`  
+  Displays all current classes.
+
+- `listClass`  
+  Displays the provided class.
+
+---
+
+### Field Commands
+- `addField`  
+  Adds a new field to a class.
+
+- `deleteField`  
+  Removes a field from a class.
+
+- `renameField`  
+  Renames a field inside a class.
+
+---
+
+### Method Commands
+- `addMethod`  
+  Adds a new method to a class with optional parameters.
+
+- `deleteMethod`  
+  Removes a method and all associated data by name from the target class.
+
+- `renameMethod` 
+  Renames a method in a class.
+
+---
+
+### Parameter Commands
+- `addParameter`  
+  Adds a parameter to a method.
+
+- `deleteParameter`  
+  Removes a parameter from a method.
+
+- `renameParameter`
+
+  Renames a parameter from a method.
+
+---
+
+### Relationship Commands
+- `addRelationship`  
+  Creates a relationship between two classes.  
+  `<Type>` can be: `REALIZATION`, `AGGREGATION`, `COMPOSITION`, `GENERALIZATION`.
+
+- `deleteRelationship` 
+  Removes all relationships involving a given class.
+
+- `listRelationships`
+  Lists all relationships created.
+
+---
+
+### System Commands
+- `help`  
+  Displays a list of all available commands.
+
+- `exit`
+  Closes the application.
+
+---
+
+### - GUI
+
+1. To create a default class you can go to the menu section, click on 'Class' and then you can add a new class along with many more options
+
+<img width="600" height="817" alt="image" src="https://github.com/user-attachments/assets/c8e2fb3d-39ef-468b-97df-b3a6b29d00f3" />
+
+2. You can click on the 'Expand Clas List' which will show all classes which have been created and if they have been added to the scene
+
+<img width="600" height="812" alt="image" src="https://github.com/user-attachments/assets/8228db0e-c511-4097-adf6-7e8cc544043d" />
+
+3. You can double click on the default class name to rename such class
+
+<img width="600" height="813" alt="image" src="https://github.com/user-attachments/assets/d00b1eac-365f-4b3b-b3d1-f34a1f806ce4" />
+
+4. You can right click on the class box to add, create, and rename such class
+
+<img width="600" height="817" alt="image" src="https://github.com/user-attachments/assets/4f34ed21-8e67-4cf1-825a-ddeb66188161" />
+
+5. To add a relationship go to the menu bar, and select 'Relations' -> 'add Relation'. You will be prompted to add a source class and target class
+<img width="600" height="815" alt="image" src="https://github.com/user-attachments/assets/f9868386-fe43-4209-b769-851bb44e3b9a" />
+<img width="600" height="816" alt="image" src="https://github.com/user-attachments/assets/8fd688e6-e0d5-48ed-83fc-b0dd826f214b" />
+
+  5a. You will be prompted to add a relationship type using a drop down, select which ever.
+   
+<img width="600" height="810" alt="image" src="https://github.com/user-attachments/assets/62bb9d10-3cd3-4041-8fe6-985cb0a1edcf" />
+
+  5b. The final result will look something like this.
+   
+<img width="600" height="812" alt="image" src="https://github.com/user-attachments/assets/6f87f24c-ac4e-4d04-869e-a0ce348c3729" />
+
+6. You can choose to save, save as 'filename', load, create new, and exit the program in the file menu button. With saving your project, it will direct you to your file explorer where you can export a photo and/or save your project.
+
+<img width="600" height="820" alt="image" src="https://github.com/user-attachments/assets/a7ad8c7e-7a27-43d0-9d34-836ea1d24932" />
+
+7. An important feature that we have recently implemented is the ability to undo and/or redo. By clicking the "UndoRedo" button on the menu bar you can undo something that you previously did as well as redo that action!
+
+ <img width="600" height="812" alt="image" src="https://github.com/user-attachments/assets/af2cf92b-9985-4a5d-ba18-915c7270a33c" />
+
+---

docs/404CompleteDesignPatternsSprint4

@@ -0,0 +1,71 @@
+Group 404 Design Patterns
+
+ Required Patterns:
+
+Model – View – Controller:
+
+Intent: with applications, there is a need to use Model View Controller setups for the importance of structuring code to align with roles of responsibility, and ease of expansion for any part within the application.
+
+The Model is the part that will hold all essential data and states associated with the application at runtime. For us, the model is best seen within the DataDefinitions package, as these are the classes that define the data and possible states of data that the application needs to store and access during use.
+
+The View is the interface that the user visually sees while they use the application. All parts of the view take care of how the internal data is represented and displayed to the user. This is best seen in our “gui” package with classes like the ClassBoxDisplay.
+
+The Controller is what orchestrates user input, updates the model, and refreshes the view. These are the buttons and commands the user has access to in order to request changes in the data, which then correspond to refreshing the view.
+
+Justification : having these coordinated, but separated in roles, structure is critical to a strong application. Each part knows what it is responsible for, and has access to communicate to the others parts as needed, without directly doing the other parts task logic within itself.
+
+
+
+Memento Pattern:
+
+Intent : Save and Restore previous states of the internal data for our application, for the purpose of allowing the user to undo, or even redo, changes they realized they did not mean to make with ease.
+
+Where it appears : DataManager, saved in an undo / redo stack like data structure. Where each snapshot is taken and stored into a queue where the undo makes a snapshot of current to push into redo, then pops the most recent change and loads it as the current save.
+
+Justification : sometimes user can be performing work with our application and find themselves realizing they did the wrong update, or the wrong move, and instead of requiring the user to directly know how to undo that move, we can instead allow them ease of an action that can undo for them, restoring the data to state they are happy with.
+
+4 Additional Patterns
+
+1. Singleton Pattern
+
+Intent - During the beginning of sprint 3 we began to refactor our project to incorporate a singleton of dataManager. The intent for this was ensuring that a class only had a single instance and provided a global point of access to it. Before we had to instantiate a new dataManager for each file and then add the new instantiated dataManager into itself. With the new implemented singleton all we have to do is grab the instance of DataManager by doing DataManager.getInstance(). SceneManager had been recently added as a singleton to avoid multiple conflicting scene/layouts.
+
+Where does it appear - DataManager, Commander, SceneManager
+
+Justification - We want one authoritative model for classes/relationships so that: CLI and GUI always see consistent data, undo/redo, save/load operate on a single shared state, we also want one command registry so new commands can be registered in one place and reused by the CLI. It is just more simple to use
+
+2. Command Pattern (~26 classes)
+
+Intent - The command pattern encapsulates a request as an object, it allows parameterization of clients with different requests, Each operation is a separate command class implementing CommandHandler. This was a no brainer for us as it made things much simpler in the long run since we've had a variation of this pattern since sprint 1
+
+Where does it appear - CommandHandler, All Commands(AddClassCommand, DeleteClassCommand, etc),  Commander, CommandProcessor
+
+Justification - Command Handler like we said before defines the command interface, with each operation being a separate command class implementing CommandHandler (e.g. AddFieldCommand, AddClassCommand, etc). Commander holds a Map registry, with the CLI using CommandProcessor to parse user input and dispatch the appropriate commandHandler This very way decouples UI from logic, the CLI and GUI menus can trigger the same commands without duplicating logic. Using this pattern centralizes undo/redo because every mutating operation goes through a command, Group 404 Design Patterns we can put snapshotForUndo() in the command at the exact point where a change occurs. It becomes Extensible ass new features are added by simply creating a new command class and registering them without modifying or changing the central execution loop
+
+3. Strategy Pattern (used 3 separate instances)
+
+ Intent - The strategy pattern defines a family of algos, encapsulates each and every one and then makes them interchangeable, this went perfectly with our text box implementation.
+
+Where does it appear - one instance of this is in our TextBoxStrategy setup, where TextBoxStrategy is the base interface, and TextBoxFieldStrategy, ...MethodStrategy, ...LabelStrategy, ...ClassStrategy all implement this to be a unique functionality.
+
+Another instance of this pattern is in our Prompt system. Where PromptCapable is our interface setup, and PromptGUI and PromptCLIJLine allow us to use a prompting system for the given setup the user is in.
+
+Lastly we also have this for our Validator system, where we are able to take our base interface Validator and change the strategy based on the type of data we are trying to validate.
+
+Justification - TextBox is a generic UI component that shows/edits text. It delegates what to do when a user presses Enter to a TextBoxStrategy, each strategy knows how to interpret the text and updates the model. The UI component doesn't need to know any of the domain rules; we reuse the same textBox for multiple kinds of data by simply swapping the strategy. This way, it is easier to add new strategies later without changing the TextBox class. This same way is used for the prompting strategies; it abstracts a way for the application to ask the user for input so we can swap between CLI prompts and GUI dialogs. IPrompt defines the behavior, PromptCLIJLine uses JLine for advanced CLI input, PromptGUI uses javaFX dialogs. Classes that need prompting implement PromptCapable.
+
+4. Observer Pattern (~ 4 classes)
+
+ Intent: communication between data structure and visual displays (the view) that doesn’t require hard coupling. With observer pattern, we can register the view to listen to changes occurring in data, and respond by updating the view for the user, so that any data changes the user should and can see, are updated in a way that provides the user the most current and accurate representation of the data.
+
+Where it appears: DataManagerObserver, RelationshipObserver, and MainViewController with Runnables wired amongst Data Types like ClassData and all its internals.
+
+ Justification: instead of hard coupling data with it’s visual representation, we can soft couple them by having the view register to listen to the Data. In this way, when any piece of data gets a call to update internals, we can notify the view that a change occurred, and the view can handle refreshing itself, without needing to directly link a data and it’s refreshment
+
+5. Template Pattern
+
+Intent: give abstract operations to subclasses in a way where those subclasses can perform these operations as needed, but follow the contract provided by the super class.
+
+Where it appears: IDraggable interface and ClassBoxDisplay which then implements it.
+
+Justification: this allows a contract for anything we’d want to be “Draggable” in our scene to follow, but each individual class that implements it could write these functions as it pertains to their specific use case.