feat: add compilation to jar file

Author: NachoBrito

src/main/java/es/nachobrito/jsonschema/compiler/application/cli/RuntimeConfiguration.java

@@ -59,7 +59,7 @@ public Optional<String> getPackageName() {
   }
 
   @Override
-  public Path getOutputFolder() {
+  public Path getOutputPath() {
     return Path.of(arguments.getOrDefault(OUTPUT, "."));
   }
 

src/main/java/es/nachobrito/jsonschema/compiler/domain/Compiler.java

@@ -23,21 +23,22 @@
 import es.nachobrito.jsonschema.compiler.domain.generator.ModelGenerator;
 import es.nachobrito.jsonschema.compiler.domain.runtimeconfiguration.RuntimeConfiguration;
 import es.nachobrito.jsonschema.compiler.domain.schemareader.SchemaReaderFactory;
-import java.io.IOException;
 import java.lang.classfile.ClassBuilder;
 import java.lang.classfile.ClassFile;
 import java.net.URI;
-import java.nio.file.Path;
 import java.util.List;
 import java.util.SortedMap;
 
 public class Compiler {
   private final RuntimeConfiguration runtimeConfiguration;
   private final SchemaReaderFactory schemaReaderFactory;
+  private final GeneratedClassesHandler generatedClassesHandler;
 
-  public Compiler(RuntimeConfiguration runtimeConfiguration, SchemaReaderFactory schemaReaderFactory) {
+  public Compiler(
+      RuntimeConfiguration runtimeConfiguration, SchemaReaderFactory schemaReaderFactory) {
     this.runtimeConfiguration = runtimeConfiguration;
     this.schemaReaderFactory = schemaReaderFactory;
+    this.generatedClassesHandler = runtimeConfiguration.getGeneratedClassesHandler();
   }
 
   /**
@@ -58,9 +59,10 @@ public void compile(String jsonSchema) {
     compileAll(schemaReaderFactory.makeSchemaReader().read(jsonSchema));
   }
 
-
   private void compileAll(List<Schema> schemas) {
+    generatedClassesHandler.beforeCompile();
     schemas.forEach(this::compileSchema);
+    generatedClassesHandler.afterCompile();
   }
 
   private void compileSchema(Schema schema) {
@@ -69,25 +71,13 @@ private void compileSchema(Schema schema) {
             .getPackageName()
             .map(pkg -> "%s.%s".formatted(pkg, schema.className()))
             .orElse(schema.className());
-    var destinationPath = buildDestinationPath(className);
     var properties = schema.properties();
 
-    try {
-      ClassFile.of()
-          .buildTo(
-              destinationPath,
-              of(className),
-              classBuilder -> writeRecord(className, classBuilder, properties));
-    } catch (IOException e) {
-      throw new CompilerException(e);
-    }
-  }
+    var bytes =
+        ClassFile.of()
+            .build(of(className), classBuilder -> writeRecord(className, classBuilder, properties));
 
-  private Path buildDestinationPath(String className) {
-    var parts = "%s.class".formatted(className.replace('.', '/'));
-    var path = Path.of(runtimeConfiguration.getOutputFolder().toAbsolutePath().toString(), parts);
-    path.getParent().toFile().mkdirs();
-    return path;
+    generatedClassesHandler.handleGeneratedClass(className, bytes);
   }
 
   private void writeRecord(

src/main/java/es/nachobrito/jsonschema/compiler/domain/GeneratedClassesHandler.java

@@ -0,0 +1,31 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.domain;
+
+public interface GeneratedClassesHandler {
+
+
+    default void beforeCompile(){
+        //Implement this method for preparatory tasks before any class is generated.
+    };
+
+    void handleGeneratedClass(String className, byte[] bytes);
+
+    default void afterCompile(){
+        //Implement this method for resource cleanup after all classes have been compiled.
+    }
+}

src/main/java/es/nachobrito/jsonschema/compiler/domain/runtimeconfiguration/RuntimeConfiguration.java

@@ -16,6 +16,9 @@
 
 package es.nachobrito.jsonschema.compiler.domain.runtimeconfiguration;
 
+import es.nachobrito.jsonschema.compiler.domain.GeneratedClassesHandler;
+import es.nachobrito.jsonschema.compiler.infrastructure.IndividualFilesHandler;
+import es.nachobrito.jsonschema.compiler.infrastructure.JarFileHandler;
 import java.nio.file.Path;
 import java.util.Optional;
 
@@ -30,7 +33,7 @@ default Optional<String> getPackageName() {
   /**
    * @return the output folder for generated class files
    */
-  default Path getOutputFolder() {
+  default Path getOutputPath() {
     return Path.of(".");
   }
 
@@ -45,4 +48,12 @@ default Optional<String> getJsonSchemaCode() {
   default boolean withJacksonAnnotations() {
     return true;
   }
+
+  default GeneratedClassesHandler getGeneratedClassesHandler(){
+    var path = getOutputPath().toAbsolutePath();
+    if (path.toString().endsWith(".jar")) {
+      return new JarFileHandler(path);
+    }
+    return new IndividualFilesHandler(path);
+  }
 }

src/main/java/es/nachobrito/jsonschema/compiler/domain/runtimeconfiguration/RuntimeConfigurationRecord.java

@@ -29,7 +29,7 @@ public Optional<String> getPackageName() {
   }
 
   @Override
-  public Path getOutputFolder() {
+  public Path getOutputPath() {
     return destPath;
   }
 }

src/main/java/es/nachobrito/jsonschema/compiler/infrastructure/IndividualFilesHandler.java

@@ -0,0 +1,54 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.infrastructure;
+
+import es.nachobrito.jsonschema.compiler.domain.CompilerException;
+import es.nachobrito.jsonschema.compiler.domain.GeneratedClassesHandler;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class IndividualFilesHandler implements GeneratedClassesHandler {
+
+
+    private final Path outputFolder;
+
+    public IndividualFilesHandler(Path outputFolder) {
+        this.outputFolder = outputFolder;
+    }
+
+    @Override
+    public void beforeCompile() {
+        outputFolder.toFile().mkdirs();
+    }
+
+    @Override
+    public void handleGeneratedClass(String className, byte[] classBytes) {
+        var destinationPath = buildDestinationPath(className);
+        try {
+            Files.write(destinationPath, classBytes);
+        } catch (IOException e) {
+            throw new CompilerException(e);
+        }
+    }
+
+    private Path buildDestinationPath(String className) {
+        var parts = "%s.class".formatted(className.replace('.', '/'));
+        return Path.of(outputFolder.toString(), parts);
+    }
+}

src/main/java/es/nachobrito/jsonschema/compiler/infrastructure/JarFileHandler.java

@@ -0,0 +1,75 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.infrastructure;
+
+import es.nachobrito.jsonschema.compiler.domain.CompilerException;
+import es.nachobrito.jsonschema.compiler.domain.GeneratedClassesHandler;
+
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+
+import static java.util.jar.Attributes.Name.MANIFEST_VERSION;
+
+public class JarFileHandler implements GeneratedClassesHandler {
+  private final Path jarFilePath;
+
+  private record Entry(String name, byte[] bytes) {}
+
+  private List<Entry> entries = new ArrayList<>();
+
+  public JarFileHandler(Path jarFilePath) {
+    this.jarFilePath = jarFilePath;
+  }
+
+  @Override
+  public void beforeCompile() {
+    if (Files.exists(jarFilePath)) {
+      throw new CompilerException(
+          "Cannot overwrite existing Jar file! -> %s".formatted(jarFilePath.toString()));
+    }
+  }
+
+  @Override
+  public void afterCompile() {
+    var manifest = new Manifest();
+    manifest.getMainAttributes().put(MANIFEST_VERSION, "1.0");
+    try (var os =
+        new JarOutputStream(
+            new BufferedOutputStream(Files.newOutputStream(jarFilePath)), manifest)) {
+      for (Entry entry : entries) {
+        os.putNextEntry(new JarEntry(entry.name()));
+        os.write(entry.bytes());
+        os.closeEntry();
+      }
+    } catch (IOException e) {
+      throw new CompilerException(e);
+    }
+  }
+
+  @Override
+  public void handleGeneratedClass(String className, byte[] bytes) {
+    var name = "%s.class".formatted(className.replace('.', '/'));
+    entries.add(new Entry(name, bytes));
+  }
+}

src/test/java/es/nachobrito/jsonschema/compiler/CompileToJarTest.java

@@ -0,0 +1,36 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CompileToJarTest extends CompilerTest{
+
+    @DisplayName("When the output path is a jar file, the generated classes have to be packed in it.")
+    @Test
+    void expectJarFilesGenerated() throws IOException, ClassNotFoundException {
+        var jar = compileSampleSchemaFromFileToJar("classpath:test-schemas/Nested.json", "com.example");
+        assertTrue(Files.exists(jar));
+    }
+
+}

src/test/java/es/nachobrito/jsonschema/compiler/CompilerSmokeTest.java

@@ -28,7 +28,6 @@
 /** Verifies basic schema compilation, and general cases for toString/hashCode/equals methods. */
 public class CompilerSmokeTest extends CompilerTest{
 
-  public static final String TARGET_GENERATED_CLASSES = "target/generated-classes";
 
   @Test
   void expectSimpleFileCompiled()

src/test/java/es/nachobrito/jsonschema/compiler/CompilerTest.java

@@ -37,6 +37,7 @@
 import org.junit.jupiter.api.BeforeEach;
 
 public class CompilerTest {
+  public static final String TARGET_GENERATED_CLASSES = "target/generated-classes";
 
   protected static Object instantiateSampleSchema(
       String filePath, String expectedName, Object... initArgs)
@@ -58,7 +59,7 @@ protected static Class<?> compileSampleSchemaFromFile(String filePath, String ex
     var compiler =
         new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReaderFactory());
     compiler.compile(uri);
-    assertTrue(destPath.toFile().exists());
+    assertTrue(Files.exists(destPath));
 
     return new URLClassLoader(new URL[] {destURL}).loadClass(expectedName);
   }
@@ -70,7 +71,7 @@ protected static Class<?> compileSampleSchemaFromString(String jsonSchema, Strin
     var compiler =
         new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReaderFactory());
     compiler.compile(jsonSchema);
-    assertTrue(destPath.toFile().exists());
+    assertTrue(Files.exists(destPath));
 
     return new URLClassLoader(new URL[] {destURL}).loadClass(expectedName);
   }
@@ -92,4 +93,15 @@ void afterAll() throws IOException {
   protected ObjectMapper createObjectMapper() {
     return new ObjectMapper().registerModule(new JavaTimeModule());
   }
+
+
+  protected Path compileSampleSchemaFromFileToJar(String schemaFile, String packageName) {
+    var uri = URI.create(schemaFile);
+    Path destPath = Path.of(CompilerSmokeTest.TARGET_GENERATED_CLASSES + "/generated.jar");
+    var compiler =
+            new Compiler(new RuntimeConfigurationRecord(destPath, packageName), new JsonSchemaReaderFactory());
+    compiler.compile(uri);
+    assertTrue(Files.exists(destPath));
+    return destPath;
+  }
 }