com.liferay.gradle.plugins.JspCDefaultsPlugin Maven / Gradle / Ivy

Go to download
/**
 * SPDX-FileCopyrightText: (c) 2000 Liferay, Inc. https://liferay.com
 * SPDX-License-Identifier: LGPL-2.1-or-later OR LicenseRef-Liferay-DXP-EULA-2.0.0-2023-06
 */

package com.liferay.gradle.plugins;

import com.liferay.gradle.plugins.extensions.BundleExtension;
import com.liferay.gradle.plugins.internal.util.FileUtil;
import com.liferay.gradle.plugins.internal.util.GradleUtil;
import com.liferay.gradle.plugins.jasper.jspc.CompileJSPTask;
import com.liferay.gradle.plugins.jasper.jspc.JspCPlugin;
import com.liferay.gradle.plugins.util.BndUtil;

import java.io.File;

import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.Callable;

import org.gradle.api.Action;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.file.CopySpec;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.DuplicatesStrategy;
import org.gradle.api.file.FileTree;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.plugins.Convention;
import org.gradle.api.plugins.ExtensionContainer;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginConvention;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.api.tasks.SourceSetOutput;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.bundling.Jar;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.util.PatternFilterable;

/**
 * @author Andrea Di Giorgi
 */
public class JspCDefaultsPlugin extends BaseDefaultsPlugin {

	public static final String COMPILE_JSP_INCLUDE_PROPERTY_NAME =
		"compile.jsp.include";

	public static final Plugin INSTANCE = new JspCDefaultsPlugin();

	@Override
	protected void applyPluginDefaults(Project project, JspCPlugin jspCPlugin) {

		// Extensions

		ExtensionContainer extensionContainer = project.getExtensions();

		final BundleExtension bundleExtension = BndUtil.getBundleExtension(
			extensionContainer);

		// Conventions

		Convention convention = project.getConvention();

		JavaPluginConvention javaPluginConvention = convention.getPlugin(
			JavaPluginConvention.class);

		SourceSetContainer javaSourceSetContainer =
			javaPluginConvention.getSourceSets();

		SourceSet javaMainSourceSet = javaSourceSetContainer.getByName(
			SourceSet.MAIN_SOURCE_SET_NAME);

		// Tasks

		final TaskProvider compileJSPTaskProvider =
			GradleUtil.getTaskProvider(
				project, JspCPlugin.COMPILE_JSP_TASK_NAME, JavaCompile.class);
		final TaskProvider generateJSPJavaTaskProvider =
			GradleUtil.getTaskProvider(
				project, JspCPlugin.GENERATE_JSP_JAVA_TASK_NAME,
				CompileJSPTask.class);
		TaskProvider jarTaskProvider = GradleUtil.getTaskProvider(
			project, JavaPlugin.JAR_TASK_NAME, Jar.class);
		TaskProvider processResourcesTaskProvider =
			GradleUtil.getTaskProvider(
				project, JavaPlugin.PROCESS_RESOURCES_TASK_NAME, Copy.class);

		_configureTaskGenerateJSPJavaProvider(
			javaMainSourceSet, generateJSPJavaTaskProvider,
			processResourcesTaskProvider);
		_configureTaskJarProvider(
			project, compileJSPTaskProvider, jarTaskProvider);
		_configureTaskProcessResourcesProvider(
			javaMainSourceSet, processResourcesTaskProvider);

		// Other

		project.afterEvaluate(
			new Action() {

				@Override
				public void execute(Project project) {
					_configureExtensionBundleAfterEvaluate(
						bundleExtension, compileJSPTaskProvider,
						generateJSPJavaTaskProvider);
				}

			});
	}

	@Override
	protected Class getPluginClass() {
		return JspCPlugin.class;
	}

	private JspCDefaultsPlugin() {
	}

	private void _configureExtensionBundleAfterEvaluate(
		BundleExtension bundleExtension,
		TaskProvider compileJSPTaskProvider,
		TaskProvider generateJSPJavaTaskProvider) {

		StringBuilder sb = new StringBuilder();

		JavaCompile compileJSPJavaCompile = compileJSPTaskProvider.get();

		DirectoryProperty directoryProperty =
			compileJSPJavaCompile.getDestinationDirectory();

		Provider provider = directoryProperty.getAsFile();

		File file = provider.getOrNull();

		if (file != null) {
			sb.append(FileUtil.getAbsolutePath(file));
			sb.append(',');
		}

		CompileJSPTask generateJSPJavaCompileJSPTask =
			generateJSPJavaTaskProvider.get();

		sb.append(
			FileUtil.getAbsolutePath(
				generateJSPJavaCompileJSPTask.getDestinationDir()));

		bundleExtension.instruction("-add-resource", sb.toString());
	}

	private void _configureTaskGenerateJSPJavaProvider(
		final SourceSet javaMainSourceSet,
		TaskProvider generateJSPJavaTaskProvider,
		final TaskProvider processResourcesTaskProvider) {

		generateJSPJavaTaskProvider.configure(
			new Action() {

				@Override
				public void execute(
					CompileJSPTask generateJSPJavaCompileJSPTask) {

					generateJSPJavaCompileJSPTask.dependsOn(
						processResourcesTaskProvider);

					generateJSPJavaCompileJSPTask.setWebAppDir(
						new Callable() {

							@Override
							public File call() throws Exception {
								SourceSetOutput sourceSetOutput =
									javaMainSourceSet.getOutput();

								return new File(
									sourceSetOutput.getResourcesDir(),
									"META-INF/resources");
							}

						});
				}

			});
	}

	private void _configureTaskJarProvider(
		final Project project,
		final TaskProvider compileJSPTaskProvider,
		TaskProvider jarTaskProvider) {

		jarTaskProvider.configure(
			new Action() {

				@Override
				public void execute(Jar jar) {
					boolean compileJspInclude = GradleUtil.getProperty(
						project, COMPILE_JSP_INCLUDE_PROPERTY_NAME, false);

					if (compileJspInclude) {
						jar.dependsOn(compileJSPTaskProvider);
					}
				}

			});
	}

	private void _configureTaskProcessResourcesProvider(
		final SourceSet javaMainSourceSet,
		TaskProvider processResourcesTaskProvider) {

		processResourcesTaskProvider.configure(
			new Action() {

				@Override
				public void execute(Copy processResourcesCopy) {
					processResourcesCopy.setDuplicatesStrategy(
						DuplicatesStrategy.INCLUDE);

					SourceDirectorySet sourceDirectorySet =
						javaMainSourceSet.getResources();

					FileTree fileTree = sourceDirectorySet.getAsFileTree();

					fileTree = fileTree.matching(
						new Action() {

							@Override
							public void execute(
								PatternFilterable patternFilterable) {

								patternFilterable.include("**/*.tld");
							}

						});

					processResourcesCopy.from(
						fileTree.getFiles(),
						new Action() {

							@Override
							public void execute(CopySpec copySpec) {
								copySpec.into("META-INF/resources/WEB-INF");
							}

						});

					Set srcDirs = sourceDirectorySet.getSrcDirs();

					Iterator iterator = srcDirs.iterator();

					if (iterator.hasNext()) {
						File tagsDir = new File(
							iterator.next(), "META-INF/tags");

						if (tagsDir.exists()) {
							processResourcesCopy.from(
								tagsDir,
								new Action() {

									@Override
									public void execute(CopySpec copySpec) {
										copySpec.into(
											"META-INF/resources/META-INF/tags");
									}

								});
						}
					}
				}

			});
	}

}