Readme and better instructions to reproduce the current functionality are now added

Author: jurra

README.md

@@ -1,51 +1,81 @@
+# QuCat Circuit Generator
 
-## Code Structure explanation
-```plaintext
-src/
-├── domain/                     # Core business logic
-│   ├── aggregates/             # Aggregate roots
-│   │   └── Circuit.js          # Circuit aggregate root
-│   ├── entities/               # Domain entities
-│   │   ├── Resistor.js         # Resistor entity
-│   │   └── Capacitor.js        # Capacitor entity
-│   ├── value-objects/          # Value objects
-│   │   ├── Position.js         # Position value object
-│   │   ├── Resistance.js       # Resistance value object
-│   │   └── Capacitance.js      # Capacitance value object
-├── application/                # Application services
-│   └── CircuitAppService.js    # Circuit application service
-├── infrastructure/             # Adapters and repositories
-│   ├── adapters/               # Adapters for external systems
-│   │   ├── CanvasAdapter.js    # Adapter for canvas interactions
-│   │   └── CircuitExporter.js  # Adapter for exporting circuits
-│   ├── repositories/           # Data persistence
-│       └── CircuitRepository.js# Circuit repository
-├── gui/                        # Graphical user interface
-│   └── index.html              # Main HTML file for the GUI
+A modular and testable project for generating and testing circuits. This application provides a user-friendly GUI to add and manipulate circuit elements like resistors and wires, along with robust testing for the core functionalities.
+
+---
+
+## **Features**
+- Add, delete, and connect circuit elements dynamically via the GUI.
+- Modular architecture with clear separation between UI, application logic, and domain layers.
+- Unit tests for ensuring functionality and maintainability.
+- Bundling with Rollup for optimized builds.
+
+---
+
+## **Setup and Usage**
+
+### **1. Clone the Repository**
+```bash
+git clone https://github.com/your-repo/qucat-circuit-generator.git
+cd qucat-circuit-generator
+```
+
+### **2. Install Dependencies**
+Install all required dependencies using npm:
+```bash
+npm install
+```
+
+### **3. Build the Project**
+Bundle the project with Rollup:
+```bash
+npm run build
 ```
+This will generate the bundled JavaScript files in the `dist` folder and copy the `gui.html` file there.
+
+### **4. Open the Application**
+After bundling, open the `gui.html` file in the `dist` folder in your browser:
+```bash
+open dist/gui.html
+```
+
+## **Testing**
+
+### **1. Run All Tests**
+Run the provided test suite using Mocha:
+```bash
+npm test
+```
+
+### **2. Test Coverage**
+- **GUIAdapter**: Tests UI bindings and integration with `CircuitService`.
+- **CircuitService**: Validates the addition, deletion, and connection of circuit elements.
+
+---
+
+## **Scripts**
 
-### Domain Layer
-- **Aggregates**: Encapsulate entities and value objects, ensuring consistency within the aggregate. 
-  - `Circuit.js`
-- **Entities**: Represent core business objects with a distinct identity.
-  - `Resistor.js`, `Capacitor.js`
-- **Value Objects**: Represent immutable concepts with no distinct identity.
-  - `Position.js`, `Resistance.js`, `Capacitance.js`
+- **Build**: Bundles the project with Rollup and copies `gui.html` to the `dist` folder.
+  ```bash
+  npm run build
+  ```
 
-### Application Layer
-- **Application Services**: Manage use cases and orchestrate domain operations.
-  - `CircuitAppService.js`
+- **Test**: Runs all tests in the `tests` folder using Mocha.
+  ```bash
+  npm test
+  ```
 
-### Infrastructure Layer
-- **Adapters**: Convert data between the domain and external systems.
-  - `CanvasAdapter.js`, `CircuitExporter.js`
-- **Repositories**: Handle data persistence and retrieval.
-  - `CircuitRepository.js`
+---
 
-### GUI Layer
-- **GUI**: Interacts with the user and connects to the application layer through adapters.
-  - `index.html`
+## **Configuration Details**
 
-## Rationale
+### **Rollup Config**
+Rollup bundles the project into the `dist` folder for optimized performance. The configuration ensures all dependencies are correctly resolved and minified.
 
-Hexagonal Architecture allows us to isolate the core business logic from external concerns, making the system more modular and easier to maintain. By organizing the code into distinct layers, we can ensure that changes in one part of the system do not affect other parts, promoting a clean separation of concerns and enhancing testability.
+### **Scripts in `package.json`**
+```json
+"scripts": {
+    "test": "mocha 'tests/**/*.test.js'",
+    "build": "rollup -c && cp gui.html dist/"
+}
+```

package.json

@@ -5,7 +5,7 @@
     "main": "main.js",
     "scripts": {
         "test": "mocha 'tests/**/*.test.js'",
-        "build": "rollup -c"
+        "build": "rollup -c && cp src/gui/gui.html dist/"
     },
     "type": "module",
     "author": "",

src/gui/gui.html

@@ -21,6 +21,6 @@ <h1>Circuit Designer</h1>
         <button id="addWire">Add Wire</button>
     </div>
     <canvas id="circuitCanvas" width="800" height="600"></canvas>
-    <script src="../../dist/bundle.js"></script>
+    <script src="./bundle.js"></script>
 </body>
 </html>