sdk.gradle

import org.apache.commons.codec.digest.DigestUtils
import org.apache.tools.ant.filters.ReplaceTokens

apply from: "util.gradle"

buildscript {
	dependencies {
		classpath group: "commons-codec", name: "commons-codec", version: "1.9"
	}

	repositories {
		maven {
			url "http://cdn.repository.liferay.com/nexus/content/groups/public"
		}
	}
}

configurations {
	portalTaglib
}

dependencies {
	portalTaglib group: "com.liferay.portal", name: "util-taglib", version: "7.0.0-SNAPSHOT"
}

repositories {
	maven {
		url "http://cdn.repository.liferay.com/nexus/content/groups/public"
	}
}

task compareDists
task createExt
task createHook
task createLayouttpl
task createPortlet
task createTheme
task createWeb

compareDists << {
	Closure compareDistFileContents
	Closure compareDistFileNames
	Closure compareDists
	Closure getFileChecksums

	List<String> antDistFileNames
	List<String> commonDistFileNames
	List<String> gradleDistFileNames

	compareDistFileContents = {
		for (String fileName : commonDistFileNames) {
			FileTree antZipFileTree = zipTree("dist/${fileName}")

			Map<String, String> antFileChecksums = getFileChecksums(antZipFileTree)

			FileTree gradleZipFileTree = zipTree("dist2/${fileName}")

			Map<String, String> gradleFileChecksums = getFileChecksums(gradleZipFileTree)

			Set<String> antFilePaths = antFileChecksums.keySet()
			Set<String> gradleFilePaths = gradleFileChecksums.keySet()

			Set<String> commonFilePaths = antFilePaths.intersect(gradleFilePaths)

			if ((antFilePaths.size() != commonFilePaths.size()) || (antFilePaths.size() != gradleFilePaths.size())) {
				println "${fileName} does not match."

				Set<String> uniqueFilePaths = antFilePaths - commonFilePaths

				if (uniqueFilePaths) {
					println "Unique files in the Ant distribution: " + uniqueFilePaths.join(", ") + "."
				}

				uniqueFilePaths = gradleFilePaths - commonFilePaths

				if (uniqueFilePaths) {
					println "Unique files in the Gradle distribution: " + uniqueFilePaths.join(", ") + "."
				}

				return false
			}

			List<String> differentChecksumFilePaths = antFileChecksums.findResults {
				filePath, antFileChecksum ->

				String gradleFileChecksum = gradleFileChecksums[filePath]

				if (antFileChecksum != gradleFileChecksum) {
					return filePath
				}

				return null
			}

			if (project.hasProperty("compareDistsExcludeSharedChecksums") && project.compareDistsExcludeSharedChecksums.toBoolean()) {
				differentChecksumFilePaths.removeAll {
					it.endsWith "-shared.jar"
				}
			}

			if (differentChecksumFilePaths) {
				println "${fileName} does not match and has different files: " + differentChecksumFilePaths.join(", ")

				return false
			}
		}

		return true
	}

	compareDistFileNames = {
		if ((antDistFileNames.size() != commonDistFileNames.size()) || (antDistFileNames.size() != gradleDistFileNames.size())) {
			println "Distribution directories contain different files."

			List<String> uniqueDistFileNames = antDistFileNames - commonDistFileNames

			if (uniqueDistFileNames) {
				println "Unique files in the Ant distribution directory: " + uniqueDistFileNames.join(", ") + "."
			}

			uniqueDistFileNames = gradleDistFileNames - commonDistFileNames

			if (uniqueDistFileNames) {
				println "Unique files in the Gradle distribution directory: " + uniqueDistFileNames.join(", ") + "."
			}

			return false
		}

		return true
	}

	compareDists = {
		FileTree antDistFileTree = fileTree(dir: "dist", include: "*.war")

		antDistFileNames = antDistFileTree*.name

		FileTree gradleDistFileTree = fileTree(dir: "dist2", include: "*.war")

		gradleDistFileNames = gradleDistFileTree*.name

		commonDistFileNames = antDistFileNames.intersect(gradleDistFileNames)

		if (!compareDistFileNames()) {
			return
		}

		if (!compareDistFileContents()) {
			return
		}

		println "Distribution directories do match."
	}

	getFileChecksums = {
		FileTree fileTree ->

		Map<String, String> fileChecksums = [:]

		fileTree.visit {
			FileVisitDetails fileVisitDetails ->

			if (fileVisitDetails.directory) {
				return
			}

			InputStream inputStream = fileVisitDetails.open()

			inputStream.withStream {
				String filePath = fileVisitDetails.relativePath
				String fileChecksum = DigestUtils.md5Hex(inputStream)

				fileChecksums[filePath] = fileChecksum
			}
		}

		return fileChecksums
	}

	compareDists()
}

createExt << {
	String extDisplayName = project.properties["extDisplayName"]
	String extName = project.properties["extName"]

	if (!extDisplayName || !extName) {
		throw new GradleException("This task must be called by the create script.")
	}

	File extDir = file("ext/${extName}-ext")

	if (extDir.exists()) {
		throw new GradleException("${extName}-ext already exists.")
	}

	copy {
		filter(
			ReplaceTokens,
			tokens: [
				"ext.display.name": extDisplayName,
				"ext.name": extName,
				"plugin.type.dir": ".."
			])

		from "${rootDir}/tools/templates/ext_tmpl"

		into extDir
	}

	mkdirs("${extDir}/docroot/WEB-INF/ext-impl/src")
	mkdirs("${extDir}/docroot/WEB-INF/ext-lib/global")
	mkdirs("${extDir}/docroot/WEB-INF/ext-lib/portal")
	mkdirs("${extDir}/docroot/WEB-INF/ext-service/src")
	mkdirs("${extDir}/docroot/WEB-INF/ext-util-bridges/src")
	mkdirs("${extDir}/docroot/WEB-INF/ext-util-java/src")
	mkdirs("${extDir}/docroot/WEB-INF/ext-util-taglib/src")
}

createHook << {
	String hookDisplayName = project.properties["hookDisplayName"]
	String hookName = project.properties["hookName"]

	if (!hookDisplayName || !hookName) {
		throw new GradleException("This task must be called by the create script.")
	}

	File hookDir = file("hooks/${hookName}-hook")

	if (hookDir.exists()) {
		throw new GradleException("${hookName}-hook already exists.")
	}

	copy {
		filter(
			ReplaceTokens,
			tokens: [
				"app.server.tomcat.manager.password": project.properties["app.server.tomcat.manager.user"],
				"app.server.tomcat.manager.user": project.properties["app.server.tomcat.manager.password"],
				"hook.display.name": hookDisplayName,
				"hook.name": hookName,
				"jmx.remote.port": project.properties["jmx.remote.port"],
				"plugin.type.dir": ".."
		])

		from "${rootDir}/tools/templates/hook_tmpl"

		into hookDir
	}
}

createLayouttpl << {
	String layouttplDisplayName = project.properties["layouttplDisplayName"]
	String layouttplName = project.properties["layouttplName"]

	if (!layouttplDisplayName || !layouttplName) {
		throw new GradleException("This task must be called by the create script.")
	}

	File layouttplDir = file("layouttpl/${layouttplName}-layouttpl")

	if (layouttplDir.exists()) {
		throw new GradleException("${layouttplName}-layouttpl already exists.")
	}

	String layouttplTemplateName = layouttplName.replaceAll("-", "_")

	copy {
		filesNotMatching("**/*.png") {
			filter(
				ReplaceTokens,
				tokens: [
					"layouttpl.display.name": layouttplDisplayName,
					"layouttpl.name": layouttplName,
					"layouttpl.template.name": layouttplTemplateName,
					"plugin.type.dir": ".."
				])
		}

		from "${rootDir}/tools/templates/layouttpl_tmpl"

		into layouttplDir

		rename {
			String fileName ->

			fileName.replace("blank_columns", layouttplTemplateName)
		}
	}
}

createPortlet << {
	Closure copyTemplate
	Closure copyTlds
	Closure createPortlet
	Closure processJSF
	Closure processSpringMVC
	Closure processTokens
	Closure processVaadin

	File portletDir
	String portletDisplayName
	String portletFramework
	String portletJavaClassName
	String portletJavaPackageName
	String portletName

	copyTemplate = {
		CopySpec portletCopySpec = copySpec {
			duplicatesStrategy "exclude"

			from "${rootDir}/tools/templates/portlet_tmpl"
		}

		if (portletFramework in ["icefaces", "liferay_faces_alloy", "primefaces", "richfaces"]) {
			portletCopySpec.from "${rootDir}/tools/templates/portlet_jsf_tmpl"
		}

		copy {
			into portletDir

			with portletCopySpec
		}

		if (portletFramework != "mvc") {
			copy {
				from "${rootDir}/tools/templates/portlet_${portletFramework}_tmpl"

				into portletDir
			}
		}
	}

	copyTlds = {
		File tldDir = file("${portletDir}/docroot/WEB-INF/tld")

		tldDir.mkdirs()

		ant.unzip(dest: tldDir, src: configurations.portalTaglib.singleFile) {
			ant.cutdirsmapper(dirs: 1)

			ant.patternset() {
				ant.include(name: "META-INF/aui.tld")
				ant.include(name: "META-INF/liferay-portlet.tld")
				ant.include(name: "META-INF/liferay-portlet-ext.tld")
				ant.include(name: "META-INF/liferay-security.tld")
				ant.include(name: "META-INF/liferay-theme.tld")
				ant.include(name: "META-INF/liferay-ui.tld")
				ant.include(name: "META-INF/liferay-util.tld")
			}
		}
	}

	createPortlet = {
		portletDisplayName = project.properties["portletDisplayName"]
		portletFramework = project.properties["portletFramework"] ?: "mvc"
		portletName = project.properties["portletName"]

		if (!portletDisplayName || !portletName) {
			throw new GradleException("This task must be called by the create script.")
		}

		portletDir = file("portlets/${portletName}-portlet")

		if (portletDir.exists()) {
			throw new GradleException("${portletName}-portlet already exists.")
		}

		portletJavaClassName = portletDisplayName.replaceAll("\\s", "")
		portletJavaClassName.trim()

		portletJavaPackageName = portletName.replace("-", "")
		portletJavaPackageName.trim()

		copyTemplate()

		if (portletFramework in ["icefaces", "jsf", "liferay_faces_alloy", "primefaces", "richfaces"]) {
			processJSF()
		}
		else if (portletFramework == "spring_mvc") {
			processSpringMVC()
		}
		else if (portletFramework == "vaadin") {
			processVaadin()
		}

		processTokens()

		copyTlds()
	}

	processJSF = {

		// liferay-plugin-package.properties

		File liferayPluginPackagePropertiesFile = file("${portletDir}/docroot/WEB-INF/liferay-plugin-package.properties")

		liferayPluginPackagePropertiesFile.withWriterAppend {
			BufferedWriter bufferedWriter ->

			String portalDependencyJars

			if (portletFramework in ["jsf", "liferay_faces_alloy", "primefaces", "richfaces"]) {
				portalDependencyJars = "commons-beanutils.jar,commons-collections.jar,commons-digester.jar,commons-fileupload.jar,commons-io.jar,commons-lang.jar"
			}
			else {
				portalDependencyJars = "commons-beanutils.jar,commons-collections.jar,commons-digester.jar,commons-lang.jar"
			}

			bufferedWriter.newLine()
			bufferedWriter.newLine()
			bufferedWriter.writeLine("portal-dependency-jars=" + portalDependencyJars)
			bufferedWriter.newLine()
			bufferedWriter.writeLine("speed-filters-enabled=false")
		}

		// liferay-portlet.xml

		File liferayPortletXmlFile = file("${portletDir}/docroot/WEB-INF/liferay-portlet.xml")

		String text = liferayPortletXmlFile.text

		text = text.replace("</icon>", """\
</icon>
		<requires-namespaced-parameters>false</requires-namespaced-parameters>
		<ajaxable>false</ajaxable>""")

		text = text.replaceAll("(?s)</header-portlet-css>(.*)</footer-portlet-javascript>", "</header-portlet-css>");

		liferayPortletXmlFile.write(text)

		// portlet.xml

		File portletXmlFile = file("${portletDir}/docroot/WEB-INF/portlet.xml")

		text = portletXmlFile.text

		text = text.replace("<portlet-class>com.liferay.portal.kernel.portlet.bridges.mvc.MVCPortlet</portlet-class>", "<portlet-class>javax.portlet.faces.GenericFacesPortlet</portlet-class>")
		text = text.replace("<name>view-template</name>", "<name>javax.portlet.faces.defaultViewId.view</name>")
		text = text.replace("<value>/view.jsp</value>", "<value>/views/view.xhtml</value>")

		portletXmlFile.write(text)

		// Delete

		ant.delete(includeEmptyDirs: true) {
			ant.fileset(dir: "${portletDir}/docroot", includes: "js/**,view.jsp")
		}
	}

	processSpringMVC = {

		// Move

		move("${portletDir}/docroot/WEB-INF/jsp/view.jsp", "${portletDir}/docroot/WEB-INF/jsp/${portletName}/view.jsp")
		move("${portletDir}/docroot/WEB-INF/spring-context/portlet-context.xml", "${portletDir}/docroot/WEB-INF/spring-context/portlet/${portletName}-portlet.xml")
		move("${portletDir}/docroot/WEB-INF/src/PortletViewController.java", "${portletDir}/docroot/WEB-INF/src/${portletJavaPackageName}/${portletJavaClassName}PortletViewController.java")

		// liferay-plugin-package.properties

		File liferayPluginPackagePropertiesFile = file("${portletDir}/docroot/WEB-INF/liferay-plugin-package.properties")

		liferayPluginPackagePropertiesFile.withWriterAppend {
			BufferedWriter bufferedWriter ->

			bufferedWriter.newLine()
			bufferedWriter.newLine()
			bufferedWriter.write("portal-dependency-jars=aopalliance.jar,commons-logging.jar,jstl-api.jar,jstl-impl.jar,spring-aop.jar,spring-beans.jar,spring-context.jar,spring-core.jar,spring-expression.jar,spring-web.jar,spring-webmvc.jar,spring-webmvc-portlet.jar")
		}

		// liferay-portlet.xml

		File liferayPortletXmlFile = file("${portletDir}/docroot/WEB-INF/liferay-portlet.xml")

		String text = liferayPortletXmlFile.text

		text = text.replace("</icon>", """\
</icon>
		<requires-namespaced-parameters>false</requires-namespaced-parameters>""")

		liferayPortletXmlFile.write(text)

		// portlet.xml

		File portletXmlFile = file("${portletDir}/docroot/WEB-INF/portlet.xml")

		text = portletXmlFile.text

		text = text.replace("<portlet-class>com.liferay.portal.kernel.portlet.bridges.mvc.MVCPortlet</portlet-class>", "<portlet-class>org.springframework.web.portlet.DispatcherPortlet</portlet-class>")
		text = text.replace("<name>view-template</name>", "<name>contextConfigLocation</name>")
		text = text.replace("<value>/view.jsp</value>", "<value>/WEB-INF/spring-context/portlet/@portlet.name@-portlet.xml</value>")

		portletXmlFile.write(text)

		// Delete

		delete("${portletDir}/docroot/view.jsp")
	}

	processTokens = {
		ant.replace(dir: portletDir) {
			ant.replacefilter(token: "@app.server.tomcat.manager.password@", value: project.properties["app.server.tomcat.manager.password"])
			ant.replacefilter(token: "@app.server.tomcat.manager.user@", value: project.properties["app.server.tomcat.manager.user"])
			ant.replacefilter(token: "@jmx.remote.port@", value: project.properties["jmx.remote.port"])
			ant.replacefilter(token: "@plugin.type.dir@", value: "..")
			ant.replacefilter(token: "@portlet.display.name@", value: portletDisplayName)
			ant.replacefilter(token: "@portlet.java.class.name@", value: portletJavaClassName)
			ant.replacefilter(token: "@portlet.java.package.name@", value: portletJavaPackageName)
			ant.replacefilter(token: "@portlet.name@", value: portletName)
		}
	}

	processVaadin = {

		// Move

		move("${portletDir}/docroot/WEB-INF/src/Application.java", "${portletDir}/docroot/WEB-INF/src/${portletJavaPackageName}/${portletJavaClassName}Application.java")

		// liferay-plugin-package.properties

		File liferayPluginPackagePropertiesFile = file("${portletDir}/docroot/WEB-INF/liferay-plugin-package.properties")

		liferayPluginPackagePropertiesFile.withWriterAppend {
			BufferedWriter bufferedWriter ->

			bufferedWriter.newLine()
			bufferedWriter.newLine()
			bufferedWriter.write("portal-dependency-jars=vaadin.jar")
		}

		// liferay-portlet.xml

		File liferayPortletXmlFile = file("${portletDir}/docroot/WEB-INF/liferay-portlet.xml")

		String text = liferayPortletXmlFile.text

		text = text.replaceAll("(?s)</icon>(.*)</footer-portlet-javascript>", "</icon>");

		text = text.replace("</icon>", """\
</icon>
		<requires-namespaced-parameters>false</requires-namespaced-parameters>
		<ajaxable>false</ajaxable>""")

		liferayPortletXmlFile.write(text)

		// portlet.xml

		File portletXmlFile = file("${portletDir}/docroot/WEB-INF/portlet.xml")

		text = portletXmlFile.text

		text = text.replace("<portlet-class>com.liferay.portal.kernel.portlet.bridges.mvc.MVCPortlet</portlet-class>", "<portlet-class>com.vaadin.terminal.gwt.server.ApplicationPortlet2</portlet-class>")
		text = text.replace("<name>view-template</name>", "<name>application</name>")
		text = text.replace("<value>/view.jsp</value>", "<value>@portlet.java.package.name@.@portlet.java.class.name@Application</value>")

		portletXmlFile.write(text)

		// Delete

		ant.delete(includeEmptyDirs: true) {
			ant.fileset(dir: "${portletDir}/docroot", includes: "css/**,js/**,view.jsp")
		}
	}

	createPortlet()
}

createTheme << {
	String themeDisplayName = project.properties["themeDisplayName"]
	String themeName = project.properties["themeName"]

	if (!themeDisplayName || !themeName) {
		throw new GradleException("This task must be called by the create script.")
	}

	File themeDir = file("themes/${themeName}-theme")

	if (themeDir.exists()) {
		throw new GradleException("${themeName}-theme already exists.")
	}

	copy {
		filter(
			ReplaceTokens,
			tokens: [
				"plugin.type.dir": "..",
				"theme.display.name": themeDisplayName,
				"theme.name": themeName
			])

		from "${rootDir}/tools/templates/theme_tmpl"

		into themeDir
	}

	mkdirs("${themeDir}/docroot/_diffs")
	mkdirs("${themeDir}/docroot/WEB-INF/src/resources-importer/document_library/documents")
	mkdirs("${themeDir}/docroot/WEB-INF/src/resources-importer/journal/articles")
	mkdirs("${themeDir}/docroot/WEB-INF/src/resources-importer/journal/structures")
	mkdirs("${themeDir}/docroot/WEB-INF/src/resources-importer/journal/templates")
}

createWeb << {
	String webDisplayName = project.properties["webDisplayName"]
	String webName = project.properties["webName"]

	if (!webDisplayName || !webName) {
		throw new GradleException("This task must be called by the create script.")
	}

	File webDir = file("webs/${webName}-web")

	if (webDir.exists()) {
		throw new GradleException("${webName}-web already exists.")
	}

	copy {
		filter(
			ReplaceTokens,
			tokens: [
				"plugin.type.dir": "..",
				"web.display.name": webDisplayName,
				"web.name": webName
			])

		from "${rootDir}/tools/templates/web_tmpl"

		into webDir
	}
}