p2-fat-jar-setup.gradle

apply from: rootProject.file('../gradle/java-setup.gradle')

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.diffplug.gradle:goomph:3.17.4"
    }
}
apply plugin: com.diffplug.gradle.p2.AsMavenPlugin

ext {
	// P2 Repository URL
	if (!project.hasProperty('p2Repository')) {
		p2Repository = "p2Repository not defined in project"
	}
	// P2 dependencies
	if (!project.hasProperty('p2Dependencies')) {
		p2Dependencies = "p2Dependencies not defined in project"
	}

	// Some JARs may include JARs themselfs, which shall be unpacked and added to the embedded class folder. 
	if (!project.hasProperty('internalJars')) {
		internalJars = []
	}

    // Include form the JARs, which goes into a fat-jar with the spottless formatter interface.
	if (!project.hasProperty('jarInclude')) {
		jarInclude = [
			'**/*.class', // Take all classes
			'**/*.properties', // Text resources (for messages, etc)
			'**/*.xml', // Plugin XML and other resources
			'*.html', // License information about the included JARs,
			'META-INF/**' // Plugin manifest and addtional information
		]
	}

    // Exclude form the JARs, which goes into a fat-jar with the spottless formatter interface.
	if (!project.hasProperty('jarExclude')) {
		jarExclude = [
			'META-INF/*.RSA', // The eclipse jars are signed, and our fat-jar breaks the signatures
			'META-INF/*.SF', // ... so all signatures are filtered
		]
	}
	
    // Exclude form the JARs, which goes into a fat-jar with the spottless formatter interface.
	if (!project.hasProperty('jarExclude')) {
		jarExclude = [
			'META-INF/*.RSA', // The eclipse jars are signed, and our fat-jar breaks the signatures
			'META-INF/*.SF', // ... so all signatures are filtered
		]
	}
	
	// Map fat-JAR resources path if JAR file name does not correspond to plugin package name (e.g. required for internal plugins)
	if (!project.hasProperty('fatJarResourcesMap')) {
		fatJarResourcesMap = [:]
	}
	  
	
	// The directory contains all external classes for the fat-jar
	embeddedClassesDirName = 'build/embeddedClasses'
	embeddedClassesDir = project.file(embeddedClassesDirName)
}

// build a maven repo in our build folder containing these artifacts
p2AsMaven {
	group 'p2', {
		repo project.p2Repository
		p2Dependencies.keySet.each { p2.addIU(it) }
		p2ant {
			/*
			Define p2ant proxy settings as a closure. Refer to the API documents for instructions:
			https://diffplug.github.io/goomph/javadoc/3.17.4/com/diffplug/gradle/p2/AsMavenPlugin.html
			*/
			if (project.hasProperty('setP2AntProxy')) {
				setP2AntProxy(it)
			}
 		}
	}
}

configurations {
	embeddedJars // P2 JARs the fat-JAR is based uppon
}

dependencies {
	p2Dependencies.each { groupArtifact, version ->
		embeddedJars "p2:${groupArtifact}:${version}"
	}
	// Includes the classes from P2 JARs during compilation
	compile files(embeddedClassesDir)
}

jar {
	// Add P2 clases to fat-JAR
	from embeddedClassesDir
}

//////////////////////////
// Unpack External Deps //
//////////////////////////
import java.io.File
import org.apache.commons.io.filefilter.DirectoryFileFilter

task unjarEmbeddedClasses {
	description = "Copies filtered set of embedded classes from the Eclise/GrEclipse dependencies to '${project.relativePath(embeddedClassesDir)}'."
	inputs.files(configurations.embeddedJars)
	inputs.property('internalJars', internalJars)
	inputs.property('jarInclude', jarInclude)
	inputs.property('jarExclude', jarExclude)
	inputs.property('fatJarResourcesMap', fatJarResourcesMap)
	outputs.file(embeddedClassesDir)

	doLast {
		embeddedClassesDir.deleteDir()
		embeddedClassesDir.mkdirs()
		configurations.embeddedJars.each {
			unjar(it, embeddedClassesDir)
		}
		// Unpack internal JARs. Maintain the order defined in internalJars
		internalJars.each {
			fileTree(embeddedClassesDir).include("${it}.jar").each {
				unjar(it, embeddedClassesDir)
				delete(it)
			}
		}
	}
}

def unjar(File jarFile, File destDir) {
	ant.unjar(src: jarFile, dest: destDir) {
		patternset {
			jarInclude.each {
				include(name: "${it}")
			}
			internalJars.each {
				include(name: "**/${it}.jar")
			}
			jarExclude.each {
				exclude(name: "${it}")
			}
		}
	}
	// Provide Fat JAR resources (following naming convention of spotless-eclipse-base)
	def fat_jar_resource_dir = jarFile.getName().split('-')[0]
	fat_jar_resource_dir = fatJarResourcesMap.getOrDefault(fat_jar_resource_dir, fat_jar_resource_dir)
	ant.move(todir: "${destDir}/${fat_jar_resource_dir}/META-INF", quiet: 'true', failonerror: 'false') {
		fileset(dir: "${destDir}/META-INF")
	}
	//Keep licenses and other human readable information for transparency
	ant.move(todir: "${destDir}/${fat_jar_resource_dir}", quiet: 'true') {
		fileset(dir: destDir) {
			include(name: '*')
			type(type: 'file')
			exclude(name: '*jar-*')
			exclude(name: '*.jar')
		}
	}

}

tasks.compileJava.dependsOn(unjarEmbeddedClasses)

/////////
// IDE //
/////////

apply plugin: 'eclipse'

// always create fresh projects
tasks.eclipse.dependsOn(cleanEclipse)
// Encure that the dependent classes are preovided for compilation if project is build via Eclipse instead of command line
tasks.eclipseClasspath.dependsOn(unjarEmbeddedClasses)

apply plugin: 'idea'

// Encure that the dependent classes are preovided for compilation if project is build via Eclipse instead of command line
tasks.idea.dependsOn(unjarEmbeddedClasses)