plugin-hub/package.gradle

/*
 * Copyright (c) 2019 Abex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import com.google.common.hash.Hashing
import com.google.common.io.Files
import com.google.gson.Gson
import java.util.jar.JarFile

initscript {
	repositories {
		jcenter()
		mavenCentral()
	}
	dependencies {
		classpath "com.github.jengelman.gradle.plugins:shadow:6.0.0"
		classpath "com.google.code.gson:gson:2.8.5"
		classpath "com.google.guava:guava:23.2-jre"
	}
	configurations.classpath.resolutionStrategy {
		// We don't have a way to add our direct deps to the metadata file,
		// so we disable it for the initscript's configuration
		disableDependencyVerification()
	}
}

allprojects {
	apply plugin: "java";
	apply plugin: com.github.jengelman.gradle.plugins.shadow.ShadowPlugin

	tasks.withType(AbstractArchiveTask) {
		preserveFileTimestamps = false
		reproducibleFileOrder = true
	}

	task rlpluginPackageJar(type: ShadowJar) {
		destinationDir = new File(System.properties["rlpluginOutputDirectory"])
		archiveName = "plugin.jar"
		configurations = [project.configurations.runtimeClasspath]
		from sourceSets.main.output
	}

	task rlpluginEmitManifest {
		// this doesn't have up-to-date stuff because we always do --no-build-cache
		
		doLast {
			def manifest = new ExternalPluginManifest()
			manifest.internalName = System.properties["rlpluginPluginID"]
			manifest.commit = System.properties["rlpluginCommit"]
			if (System.properties["rlpluginWarning"]) {
				manifest.warning = System.properties["rlpluginWarning"];
			}

			def pluginJar = new File(System.properties["rlpluginOutputDirectory"], "plugin.jar");
			manifest.hash = Files.asByteSource(pluginJar)
				.hash(Hashing.sha256())
				.toString()
			manifest.size = pluginJar.length()

			if (manifest.size > 10 * 1024 * 1024) {
				throw new RuntimeException("The output jar is ${manifest.size.intdiv(1024 * 1024)}MiB, which is above our limit of 10MiB")
			}

			def props = new Properties()
			new FileInputStream(file("runelite-plugin.properties")).withCloseable { is ->
				props.load(is)
			}

			manifest.plugins = props["plugins"].split(/[,:;]/)*.trim()
			new JarFile(pluginJar).withCloseable{ jf ->
				manifest.plugins.each { plugin ->
					if (jf.getEntry(plugin.replaceAll(~/\./, "/") + ".class") == null) {
						throw new RuntimeException("Plugin class \"" + plugin + "\" is not in the output jar")
					}
				}
			}

			manifest.displayName = props["displayName"]
			if (!manifest.displayName) {
				throw new RuntimeException("Plugin must have a display name")
			}
			manifest.author = props["author"]
			if (!manifest.author) {
				throw new RuntimeException("Plugin must have an author")
			}
			if (props["support"]) {
				manifest.support = new URL(props["support"])
			}
			manifest.description = props["description"] ?: null
			if (props["tags"]) {
				manifest.tags = props["tags"].split(",")*.trim()
			}

			manifest.version = project.version
			if (!(manifest.version ==~ /^[a-zA-Z0-9.-]+$/)) {
				throw new RuntimeException("Plugin version \"${manifest.version}\" is invalid");
			}
			
			manifest.hasIcon = file("icon.png").exists();

			new File(System.properties["rlpluginOutputDirectory"], "plugin.manifest")
				.text = new Gson().toJson(manifest);
		}
	}

	rlpluginEmitManifest.dependsOn rlpluginPackageJar

	task configured {
		def runeLiteDeps = [
			"client",
			"runelite-api",
			"http-api",
		]
		def version = System.properties["rlpluginRuneLiteVersion"]
		configurations.all {
			resolutionStrategy.eachDependency { DependencyResolveDetails details -> 
				if (details.requested.group == "net.runelite" && details.requested.name in runeLiteDeps) {
					details.useVersion version
				}
			}
		}
	}
}

class ExternalPluginManifest {
	String internalName;
	String commit;
	String hash;
	int size;
	String[] plugins;

	String displayName;
	String version;
	String author;
	String description;
	String warning;
	String[] tags;
	URL support;
	boolean hasIcon;
}