feat: readme update and encpasulation of class loading by bootstrap

Author: Traqueur-dev

README.md

@@ -36,29 +36,25 @@ dependencies {
 
     // Mark dependencies as dynamic
     // They will be available at compile time but NOT included in the JAR
-    dynamic("net.dv8tion:JDA:6.1.2")
-    dynamic("com.google.guava:guava:32.1.3-jre")
+    bootstrap("net.dv8tion:JDA:6.1.2")
+    bootstrap("com.google.guava:guava:32.1.3-jre")
 }
 ```
 
 ### 2. Use the simple bootstrap API
 
 **Main.java:**
 ```java
-import fr.traqueur.bootstrap.BootstrapLoader;
 
 public class Main {
     public static void main(String[] args) {
-        DynamicLoader.bootstrap(args, MyApp.class);
+        BootstrapLoader.bootstrap(args, MyApp.class);
     }
 }
 ```
 
 **MyApp.java:**
 ```java
-import fr.traqueur.bootstrap.BootstrapApplication;
-import net.dv8tion.jda.api.JDA;
-import net.dv8tion.jda.api.JDABuilder;
 
 public class MyApp implements DynamicApplication {
     private JDA jda;  // You can use dynamic dependency types directly!
@@ -84,14 +80,14 @@ On first run, dependencies will be downloaded to `.dynamic-loader/cache/`.
 
 ### Build Time
 
-1. The Gradle plugin creates a `dynamic` configuration extending `compileOnly`
+1. The Gradle plugin creates a `boostrap` configuration extending `compileOnly`
 2. Dynamic dependencies are available during compilation
-3. A manifest file `META-INF/dynamic-dependencies.json` is generated
+3. A manifest file `META-INF/bootstrap-dependencies.json` is generated
 4. Dynamic dependencies are **excluded** from the JAR
 
 ### Runtime
 
-1. `DynamicLoader.bootstrap()` loads the manifest
+1. `BootstrapLoader.bootstrap()` loads the manifest
 2. Maven Resolver downloads dependencies and their transitive dependencies
 3. An **IsolatedClassLoader** (child-first) is created with the dependencies
 4. Your application class is loaded and instantiated via the isolated ClassLoader
@@ -113,7 +109,7 @@ This is crucial for allowing your application classes to reference types from dy
 For more control over initialization:
 
 ```java
-DynamicLoader.bootstrap(args, ctx -> {
+BootstrapLoader.bootstrap(args, ctx -> {
     MyApp app = ctx.create(MyApp.class);
 
     // Access the ClassLoader
@@ -132,10 +128,10 @@ Via system property or environment variable:
 
 ```bash
 # System property
-java -Ddynamicloader.cache.dir=/custom/cache -jar app.jar
+java -Dbootstraploader.cache.dir=/custom/cache -jar app.jar
 
 # Environment variable
-export DYNAMIC_LOADER_CACHE_DIR=/custom/cache
+export BOOTSTRAP_LOADER_CACHE_DIR=/custom/cache
 java -jar app.jar
 ```
 
@@ -159,9 +155,9 @@ These repositories are included in the generated manifest.
 ```
 Bootstrap/
 ├── bootstrap-core/               # Runtime library (Java 21)
-│   ├── DynamicLoader.java        # Main entry point
-│   ├── DynamicApplication.java   # Simple interface
-│   ├── DynamicEntrypoint.java    # Callback interface
+│   ├── BootstrapLoader.java        # Main entry point
+│   ├── BootstrapApplication.java   # Simple interface
+│   ├── BootstrapEntrypoint.java    # Callback interface
 │   ├── config/
 │   │   └── DependencyManifest.java   # JSON parser
 │   ├── loader/
@@ -172,16 +168,16 @@ Bootstrap/
 │       └── SimpleTransferListener.java
 │
 ├── bootstrap-gradle/             # Gradle plugin (Kotlin)
-│   ├── DynamicLoaderPlugin.kt
-│   ├── DynamicLoaderExtension.kt
+│   ├── BootstrapLoaderPlugin.kt
+│   ├── BootstrapLoaderExtension.kt
 │   └── GenerateDynamicManifestTask.kt
 │
 └── example/                      # Discord bot example
 ```
 
 ## Manifest Format
 
-**META-INF/dynamic-dependencies.json:**
+**META-INF/bootstrap-dependencies.json:**
 ```json
 {
   "dependencies": [

bootstrap-core/src/main/java/fr/traqueur/bootstrap/loader/LoaderContext.java

@@ -1,44 +1,15 @@
 package fr.traqueur.bootstrap.loader;
 
+import fr.traqueur.bootstrap.BootstrapApplication;
 import fr.traqueur.bootstrap.BootstrapEntrypoint;
 
 /**
  * Context object provided to {@link BootstrapEntrypoint} callbacks.
  * This context provides access to the isolated ClassLoader and utility methods.
+ * @param classLoader the isolated ClassLoader containing dynamic dependencies
+ * @param args        the command line arguments
  */
-public class LoaderContext {
-
-    private final IsolatedClassLoader classLoader;
-    private final String[] args;
-
-    /**
-     * Creates a new loader context.
-     *
-     * @param classLoader the isolated ClassLoader containing dynamic dependencies
-     * @param args the command line arguments
-     */
-    public LoaderContext(IsolatedClassLoader classLoader, String[] args) {
-        this.classLoader = classLoader;
-        this.args = args;
-    }
-
-    /**
-     * Gets the isolated ClassLoader.
-     *
-     * @return the ClassLoader with dynamic dependencies
-     */
-    public IsolatedClassLoader getClassLoader() {
-        return classLoader;
-    }
-
-    /**
-     * Gets the command line arguments.
-     *
-     * @return the arguments passed to the application
-     */
-    public String[] args() {
-        return args;
-    }
+public record LoaderContext(IsolatedClassLoader classLoader, String[] args) {
 
     /**
      * Creates an instance of the specified class using the isolated ClassLoader.
@@ -49,17 +20,17 @@ public String[] args() {
      * reflection with the no-args constructor.</p>
      *
      * @param clazz the class to instantiate
-     * @param <T> the type of the class
+     * @param <T>   the type of the class
      * @return a new instance of the class
      * @throws RuntimeException if instantiation fails
      */
-    public <T> T create(Class<T> clazz) {
+    public <T extends BootstrapApplication> T create(Class<T> clazz) {
         try {
             // Load class through isolated ClassLoader
-            Class<?> loadedClass = classLoader.loadClass(clazz.getName());
+            Class<BootstrapApplication> loadedClass = this.loadClass(clazz.getName());
 
             // Create instance using reflection
-            Object instance = loadedClass.getDeclaredConstructor().newInstance();
+            BootstrapApplication instance = loadedClass.getDeclaredConstructor().newInstance();
 
             // Cast to expected type
             return clazz.cast(instance);
@@ -75,7 +46,11 @@ public <T> T create(Class<T> clazz) {
      * @return the loaded class
      * @throws ClassNotFoundException if the class cannot be found
      */
-    public Class<?> loadClass(String className) throws ClassNotFoundException {
-        return classLoader.loadClass(className);
+    @SuppressWarnings("unchecked")
+    public Class<BootstrapApplication> loadClass(String className) throws ClassNotFoundException {
+        Class<?> clazz = classLoader.loadClass(className);
+        if (BootstrapApplication.class.isAssignableFrom(clazz))
+            return (Class<BootstrapApplication>) clazz;
+        throw new ClassNotFoundException(className);
     }
 }

gradle.properties

@@ -2,4 +2,4 @@ org.gradle.jvmargs=-Xmx2g
 kotlin.code.style=official
 
 group=fr.traqueur.bootstrap
-version=1.0.2
+version=1.0.3