fat jar

build.gradle

@@ -32,7 +32,9 @@ dependencies {
     implementation("info.clearthought:table-layout:4.3.0")
     implementation("insight:JHotDraw:7.0.9")
     implementation("net.imagej:ij:1.48s")
-    implementation("net.java.dev.jna:jna-platform:5.3.0")
+    implementation("net.java.dev.jna:jna-platform:4.5.2") {
+        exclude group: "com.sun.jna", module: "jna"
+    }
     implementation("org.apache.poi:poi:4.0.1")
     implementation("org.apache.commons:commons-collections4:4.3")
     implementation("org.apache.httpcomponents:httpmime:4.5.7")

buildSrc/build.gradle

@@ -11,6 +11,7 @@ repositories {
 
 dependencies {
     implementation "org.openmicroscopy:omero-javapackager-plugin:5.5.1"
+    implementation "com.github.jengelman.gradle.plugins:shadow:5.1.0"
 }
 
 gradlePlugin {

buildSrc/src/main/groovy/org/openmicroscopy/DistributePlugin.groovy

@@ -71,7 +71,8 @@ class DistributePlugin implements Plugin<Project> {
 
         configureMainDistribution(distributionContainer, configSpec)
         createImporterDistribution(distributionContainer, configSpec)
-        createImageJPluginDistribution(distributionContainer, configSpec)
+        //createImageJPluginDistribution(distributionContainer, configSpec)
+        createImageJFatJarPluginDistribution(distributionContainer, configSpec)
 
         // Skip tar tasks
         project.tasks.withType(Tar).configureEach {
@@ -101,7 +102,7 @@ class DistributePlugin implements Plugin<Project> {
     }
 
     private void createImporterDistribution(DistributionContainer distributionContainer, CopySpec configSpec) {
-        // Create and configure imageJ distribution
+        // Create and configure importer distribution
         distributionContainer.create(DISTRIBUTION_IMPORTER) { Distribution importer ->
             importer.baseName = DISTRIBUTION_NAME_IMPORTER
             importer.contents.with(configSpec)
@@ -120,20 +121,17 @@ class DistributePlugin implements Plugin<Project> {
         }
     }
 
-    private void createImageJPluginDistribution(DistributionContainer distributionContainer, CopySpec configSpec) {
+    private void createImageJFatJarPluginDistribution(DistributionContainer distributionContainer, CopySpec configSpec) {
         // Create and configure imageJ distribution
         distributionContainer.create(DISTRIBUTION_IMAGEJ) { Distribution imageJ ->
             imageJ.baseName = DISTRIBUTION_NAME_IMAGEJ
             imageJ.contents.with(configSpec)
 
-            CopySpec libChildSpec = createLibSpec(null)
-
             CopySpec mainSpec = project.copySpec()
             mainSpec.into("")
-            mainSpec.from(project.tasks.named(InsightBasePlugin.TASK_OMERO_IMAGEJ_JAR))
+            mainSpec.from(project.tasks.named(InsightBasePlugin.TASK_OMERO_IMAGEJ_FAT_JAR))
 
             CopySpec childSpec = project.copySpec()
-            childSpec.with(libChildSpec)
             childSpec.with(mainSpec)
 
             imageJ.contents.with(childSpec)

buildSrc/src/main/groovy/org/openmicroscopy/InsightBasePlugin.groovy

@@ -20,11 +20,14 @@
  */
 package org.openmicroscopy
 
+import com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import groovy.transform.CompileStatic
 import org.gradle.api.Action
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.artifacts.Configuration
 import org.gradle.api.plugins.BasePlugin
 import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.plugins.JavaPluginConvention
@@ -42,6 +45,8 @@ class InsightBasePlugin implements Plugin<Project> {
 
     public static final String TASK_OMERO_IMAGEJ_JAR = "imageJJar"
 
+    public static final String TASK_OMERO_IMAGEJ_FAT_JAR = TASK_OMERO_IMAGEJ_JAR//"imageJFatJar"
+
     public static final String MAIN_INSIGHT = "org.openmicroscopy.shoola.Main"
 
     public static final String MAIN_IMAGEJ = "org.openmicroscopy.shoola.MainIJPlugin"
@@ -57,10 +62,11 @@ class InsightBasePlugin implements Plugin<Project> {
         this.project = project
 
         project.pluginManager.apply(JavaPlugin)
+        project.pluginManager.apply(ShadowBasePlugin)
 
         configureJarTask()
         addProcessConfigs()
-        addCreateImageJJar()
+        addCreateImageJFatJar()
     }
 
     /**
@@ -94,34 +100,64 @@ class InsightBasePlugin implements Plugin<Project> {
         processConfigs
     }
 
-    private TaskProvider<Jar> addCreateImageJJar() {
-        JavaPluginConvention javaPluginConvention =
-                project.convention.getPlugin(JavaPluginConvention)
+    private TaskProvider<ShadowJar> addCreateImageJFatJar() {
+        JavaPluginConvention convention = project.convention.getPlugin(JavaPluginConvention)
 
         SourceSet main =
-                javaPluginConvention.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
+                convention.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
 
-        project.tasks.register(TASK_OMERO_IMAGEJ_JAR, Jar, new Action<Jar>() {
+        project.tasks.register(TASK_OMERO_IMAGEJ_FAT_JAR, ShadowJar, new Action<ShadowJar>() {
             @Override
-            void execute(Jar jar) {
-                // This might not be the best way to ensure a parity of names
+            void execute(ShadowJar shadow) {
+                // Rename omero-insight to omero_ij
                 Jar jarTask = project.tasks.getByName(JavaPlugin.JAR_TASK_NAME) as Jar
 
-                // Rename omero-insight to omero_ij
-                String imageJName = jarTask.archiveBaseName.get().replace("insight", "ij")
-                imageJName = imageJName.replace("-", "_")
-
-                jar.setDescription("Assembles a jar for use with ImageJ")
-                jar.setGroup(GROUP_BUILD)
-                jar.dependsOn(project.tasks.getByName(JavaPlugin.CLASSES_TASK_NAME))
-                jar.from(main.output)
-                jar.archiveBaseName.set(imageJName)
-                jar.doFirst(addManifest(MAIN_IMAGEJ, "lib"))
+                shadow.archiveBaseName.set(createImageJName(jarTask, "ij"))
+                shadow.archiveClassifier.set("all")
+                shadow.description = "Create a combined JAR of project and runtime dependencies"
+                shadow.conventionMapping.with {
+                    map('classifier') {
+                        'all'
+                    }
+                }
+
+                shadow.manifest.inheritFrom jarTask.manifest
+                shadow.configurations = [Utils.getRuntimeClasspathConfiguration(project)]
+                shadow.exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA',
+                        'META-INF/*.RSA', 'module-info.class')
+                shadow.from(main.output)
+                shadow.doFirst(addShadowConfigToClassPath())
             }
         })
     }
 
+    private String createImageJName(Jar jarTask, String replacement) {
+        // Rename omero-insight to omero_ij
+        String imageJName = jarTask.archiveBaseName.get().replace("insight", replacement)
+        return imageJName.replace("-", "_")
+    }
+
+    private Action<? extends Task> addShadowConfigToClassPath() {
+        return new Action<ShadowJar>() {
+            @Override
+            void execute(ShadowJar shadow) {
+                Configuration shadowConfig =
+                        project.configurations.findByName(ShadowBasePlugin.CONFIGURATION_NAME)
+
+                if (shadowConfig) {
+                    if (shadowConfig.files) {
+                        Jar jarTask = project.tasks.getByName(JavaPlugin.JAR_TASK_NAME) as Jar
+                        def libs = [jarTask.manifest.attributes.get('Class-Path')]
+                        libs.addAll shadowConfig.files.collect { "${it.name}" }
+                        shadow.manifest.attributes['Class-Path'] = libs.findAll { it }.join(' ')
+                    }
+                }
+            }
+        }
+    }
+
     private Action<? extends Task> addManifest(String mainClass, String classPathDir = "") {
+
         return new Action<Jar>() {
             @Override
             void execute(Jar jar) {