build-plugins.gradle

import com.liferay.portal.kernel.util.ReleaseInfo

import org.gradle.api.internal.file.copy.CopySpecResolver

apply plugin: "war"

buildscript {
	dependencies {
		classpath group: "com.liferay.portal", name: "portal-service", version: "7.0.0-SNAPSHOT"
	}

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

configurations {
	pluginRequiredLibraries
	portalTools
	portalToolsBuildCss
	portalToolsBuildCssLegacy
	portalToolsFormatSource
	portalWeb

	portalToolsBuildCss.extendsFrom portalTools, portalToolsBuildCssLegacy
	portalToolsFormatSource.extendsFrom portalTools

	if (!name.endsWith("-theme")) {
		providedCompile.extendsFrom pluginRequiredLibraries
	}
}

dependencies {
	compile(
		{
			File projectServiceJarFile = file("docroot/WEB-INF/lib/${name}-service.jar")

			if (projectServiceJarFile.exists()) {
				return [files(projectServiceJarFile)]
			}

			return []
		}(),
		{
			if (!name.endsWith("-layouttpl") && !name.endsWith("-theme") && !name.equals("portal-compat-shared")) {
				return [project(":shared:portal-compat-shared")]
			}

			return []
		}()
	)

	pluginRequiredLibraries(
		[group: "com.liferay.portal", name: "util-bridges", version: "7.0.0-SNAPSHOT"],
		[group: "com.liferay.portal", name: "util-java", version: "7.0.0-SNAPSHOT"],
		[group: "com.liferay.portal", name: "util-taglib", version: "7.0.0-SNAPSHOT"],
		[group: "commons-logging", name: "commons-logging", version: "1.1.1"],
		[group: "log4j", name: "log4j", version: "1.2.16"]
	)

	portalTools(
		[group: "com.liferay.portal", name: "portal-impl", version: "7.0.0-SNAPSHOT"],
		[group: "com.liferay.portal", name: "portal-service", version: "7.0.0-SNAPSHOT"],
		[group: "com.liferay.portal", name: "util-java", version: "7.0.0-SNAPSHOT"],
		[group: "com.thoughtworks.xstream", name: "xstream", version: "1.4.3"],
		[group: "commons-configuration", name: "commons-configuration", version: "1.6"],
		[group: "commons-lang", name: "commons-lang", version: "2.6"],
		[group: "easyconf", name: "easyconf", version: "0.9.5", transitive: false],
		[group: "javax.servlet", name: "javax.servlet-api", version: "3.0.1"]
	)

	portalToolsBuildCss(
		[group: "com.liferay", name: "com.liferay.sass.compiler", version: "1.0.0-SNAPSHOT"],
		[group: "org.apache.ant", name: "ant", version: "1.8.2"],
		[group: "org.mozilla", name: "rhino", version: "1.7R4"]
	)

	portalToolsBuildCssLegacy(
		[group: "com.liferay", name: "com.liferay.ruby.gems", version: "1.0.0-SNAPSHOT"],
		[group: "javax.portlet", name: "portlet-api", version: "2.0"],
		[group: "org.jruby", name: "jruby-complete", version: "1.6.5"],
		[group: "org.springframework", name: "spring-web", version: "3.2.10.RELEASE"],
		[group: "struts", name: "struts", version: "1.2.9"]
	)

	portalToolsFormatSource(
		[group: "com.thoughtworks.qdox", name: "qdox", version: "1.12.1"],
		[group: "dom4j", name: "dom4j", version: "1.6.1"],
		[group: "org.apache.ant", name: "ant", version: "1.8.2"],
		[group: "xerces", name: "xercesImpl", version: "2.11.0"]
	)

	portalWeb group: "com.liferay.portal", name: "portal-web", version: "7.0.0-SNAPSHOT"

	providedCompile(
		[group: "biz.aQute.bnd", name: "biz.aQute.bnd", version: "2.4.1"],
		[group: "com.liferay.portal", name: "portal-service", version: "7.0.0-SNAPSHOT"],
		[group: "hsqldb", name: "hsqldb", version: "1.8.0.7"],
		[group: "javax.activation", name: "activation", version: "1.1"],
		[group: "javax.ccpp", name: "ccpp", version: "1.0"],
		[group: "javax.jms", name: "jms", version: "1.1"],
		[group: "javax.mail", name: "mail", version: "1.4"],
		[group: "javax.portlet", name: "portlet-api", version: "2.0"],
		[group: "javax.servlet", name: "javax.servlet-api", version: "3.0.1"],
		[group: "javax.servlet.jsp", name: "jsp-api", version: "2.1"],
		[group: "mysql", name: "mysql-connector-java", version: "5.1.23"],
		[group: "net.sf", name: "jargs", version: "1.0"],
		[group: "net.sourceforge.jtds", name: "jtds", version: "1.2.6"],
		[group: "org.eclipse.persistence", name: "javax.persistence", version: "2.0.0"],
		[group: "postgresql", name: "postgresql", version: "9.2-1002.jdbc4"]
	)
}

sourceSets {
	main {
		java {
			srcDir pluginSrcDir
		}

		resources {
			srcDir pluginSrcDir
		}
	}
}

version = {
	String moduleFullVersion = pluginPackageProperties["module-full-version"]

	if (moduleFullVersion) {
		return moduleFullVersion
	}
	else {
		String bundleVersion = bndProperties["Bundle-Version"]

		if (bundleVersion) {
			return bundleVersion
		}
		else {
			String moduleIncrementalVersion = pluginPackageProperties["module-incremental-version"]

			return ReleaseInfo.version + "." + moduleIncrementalVersion
		}
	}
}()

webAppDirName = "docroot"

task buildCss(type: JavaExec)
task compile
task formatSource(type: JavaExec)
task initGradle

buildCss {
	File sassDocrootDir
	FileTree sassDocrootDirFileTree

	sassDocrootDir = {
		if (osgiPlugin) {
			return file("src/META-INF/resources")
		}
		else {
			return file("docroot")
		}
	}()

	sassDocrootDirFileTree = fileTree(dir: sassDocrootDir, exclude: "**/.sass-cache/**", include: "**/*.css")

	args(
		"sass.dir=/",
		"sass.docroot.dir=${sassDocrootDir}",
		"sass.portal.common.dir=${rootDir}/tmp/portal-web/html/css/common"
	)

	classpath configurations.portalToolsBuildCss

	doFirst {
		if (!exists("${rootDir}/tmp/portal-web")) {
			copy {
				from(zipTree(configurations.portalWeb.singleFile)) {
					include "html/css/**/*"
					include "html/themes/**/*"
					include "WEB-INF/tld/**/*"
				}

				into "${rootDir}/tmp/portal-web"
			}
		}
	}

	inputs.files sassDocrootDirFileTree

	main = "com.liferay.portal.tools.SassToCssBuilder"

	onlyIf {
		sassDocrootDirFileTree.files
	}

	outputs.dir "${rootDir}/tmp"
	outputs.dir(
		{
			sassDocrootDirFileTree.each {
				return "${it}/../.sass-cache"
			}
		}()
	)
}

classes {
	dependsOn buildCss
}

clean {
	afterEvaluate {
		tasks.each {
			dependsOn "clean" + it.name.capitalize()
		}

		Set<ProjectDependency> projectDependencies = configurations.compile.allDependencies.withType(ProjectDependency)

		projectDependencies.each {
			dependsOn "${it.dependencyProject.path}:clean"
		}
	}
}

compile {
	dependsOn compileJava
}

formatSource {
	classpath configurations.portalToolsFormatSource

	main = "com.liferay.portal.tools.sourceformatter.SourceFormatter"

	maxHeapSize = "512m"
}

formatSource << {
	delete "ServiceBuilder.temp"
}

initGradle << {
	Closure getBuildGradleDependencies
	Closure getBuildGradleDependenciesCompile
	Closure getBuildGradleDependenciesProvidedCompile
	Closure getBuildGradleDependenciesTestCompile
	Closure getBuildGradleExt
	Closure getBuildXmlProperty
	Closure getIndent
	Closure readLegacyXmls
	Closure wrapContents
	Closure wrapDependency
	Closure wrapProjectDependency
	Closure wrapProperty
	Closure wrapServiceJar
	Closure writeBuildGradleFile
	Closure writeDependencySettingsFile

	Node buildXmlNode
	Node ivyXmlNode

	getBuildGradleDependencies = {
		List<String> contents = []

		contents.addAll(getBuildGradleDependenciesCompile())
		contents.addAll(getBuildGradleDependenciesProvidedCompile())
		contents.addAll(getBuildGradleDependenciesTestCompile())

		return wrapContents(contents, 0, " {", "dependencies", "}")
	}

	getBuildGradleDependenciesCompile = {
		List<String> contents = []

		if (ivyXmlNode) {
			ivyXmlNode.dependencies.dependency.each {
				if (!it.@conf || (it.@conf == "default")) {
					contents.addAll(wrapDependency(2, it.@org, it.@name, it.@rev))
				}
			}
		}

		String requiredDeploymentContexts = pluginPackageProperties["required-deployment-contexts"]

		if (requiredDeploymentContexts) {
			String[] requiredDeploymentContextsArray = requiredDeploymentContexts.split(",")

			requiredDeploymentContextsArray.each {
				String serviceJarFileName = "../../" + it.replaceFirst(".+-", "") + "s/${it}/docroot/WEB-INF/lib/${it}-service.jar"

				File serviceJarFile = file(serviceJarFileName)

				if (serviceJarFile.exists()) {
					contents.addAll(wrapServiceJar(2, serviceJarFileName))
				}
			}
		}

		String importShared = getBuildXmlProperty("import.shared")

		if (importShared) {
			String[] importSharedArray = importShared.split(",")

			importSharedArray.each {
				String projectDependencyPath

				if (exists("${rootDir}/shared/${it}/src")) {
					projectDependencyPath = ":shared:${it}"
				}
				else if (exists("${projectDir}/../${it}/src")) {
					projectDependencyPath = project.path.replaceFirst(project.name, it)
				}
				else {
					println("Project dependency ${it} could not be found in the shared directory or this project's parent directory.")

					return
				}

				contents.addAll(wrapProjectDependency(2, projectDependencyPath))
			}
		}

		return wrapContents(contents, 1, "(", "compile", ")")
	}

	getBuildGradleDependenciesProvidedCompile = {
		List<String> contents = []

		String portalDependencyJars = pluginPackageProperties["portal-dependency-jars"]

		if (portalDependencyJars) {
			portalDependencyJars = portalDependencyJars.replaceAll("\\.jar", "")
			portalDependencyJars = portalDependencyJars.replaceAll("-\\w") {
				it[1].toUpperCase()
			}

			String[] portalDependencyJarsArray = portalDependencyJars.split(",")

			portalDependencyJarsArray.each {
				String portalDependencyJar ->

				Map<String, String> portalDependencyJarMap = portalDependencies[portalDependencyJar]

				if (!portalDependencyJarMap) {
					println("Portal dependency " + portalDependencyJar + " is not defined in versions.gradle")
				}
				else {
					contents.addAll(wrapDependency(2, portalDependencyJarMap["group"], portalDependencyJarMap["name"], portalDependencyJarMap["version"]))
				}
			}

		}

		return wrapContents(contents, 1, "(", "providedCompile", ")")
	}

	getBuildGradleDependenciesTestCompile = {
		List<String> contents = []

		if (ivyXmlNode) {
			ivyXmlNode.dependencies.dependency.each {
				if (it.@conf =~ "test") {
					contents.addAll(wrapDependency(2, it.@org, it.@name, it.@rev))
				}
			}
		}

		return wrapContents(contents, 1, "(", "testCompile", ")")
	}

	getBuildGradleExt = {
		List<String> contents = []

		if (project.name.endsWith("-theme")) {
			String themeParent = getBuildXmlProperty("theme.parent")

			if (themeParent) {
				contents.add(wrapProperty(1, "themeParent", themeParent))
			}

			String themeType = getBuildXmlProperty("theme.type", "vm")

			contents.add(wrapProperty(1, "themeType", themeType))
		}

		if (contents) {
			contents = wrapContents(contents, 0, " {", "ext", "}")
		}

		return contents
	}

	getBuildXmlProperty = {
		String key, String defaultValue = "" ->

		String value = defaultValue

		Node buildXmlPropertyNode = buildXmlNode.property.find {
			it.@name == key
		}

		if (buildXmlPropertyNode) {
			value = buildXmlPropertyNode.@value
		}

		return value
	}

	getIndent = {
		String indent = ""

		it.times(
		{
			indent = indent + "\t"
		})

		return indent
	}

	readLegacyXmls = {

		// build.xml

		XmlParser xmlParser = new XmlParser()

		xmlParser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)

		File buildXmlFile = file("build.xml")

		if (buildXmlFile.exists()) {
			buildXmlNode = xmlParser.parse(buildXmlFile)
		}

		// ivy.xml

		File ivyXmlFile = file("ivy.xml")

		if (ivyXmlFile.exists()) {
			ivyXmlNode = xmlParser.parse(ivyXmlFile)
		}
	}

	wrapContents = {
		List<String> contents, int indentCount, String leftClose, String name, String rightClose ->

		if (!contents) {
			return contents
		}

		String indent = getIndent(indentCount)

		contents.add(0, indent + name + leftClose)

		String content = contents.last()

		if (content.endsWith(",")) {
			contents.pop()

			contents << content.substring(0, content.length() - 1)
		}

		contents << indent + rightClose

		return contents
	}

	wrapDependency = {
		int indentCount, String group, String name, String version ->

		return "${getIndent(indentCount)}[group: \"${group}\", name: \"${name}\", version: \"${version}\"],"
	}

	wrapProjectDependency = {
		int indentCount, String projectDependencyPath ->

		return "${getIndent(indentCount)}project(\"${projectDependencyPath}\"),"
	}

	wrapProperty = {
		int indentCount, String name, String value = "" ->

		if (value) {
			return "${getIndent(indentCount)}${name} = \"${value}\""
		}

		return []
	}

	wrapServiceJar = {
		int indentCount, String serviceJarFileName ->

		return "${getIndent(indentCount)}files(\"${serviceJarFileName}\"),"
	}

	writeBuildGradleFile = {
		List<String> contents = []

		contents.addAll(getBuildGradleDependencies())
		contents.addAll(getBuildGradleExt())

		File buildGradleFile = file("build.gradle")

		buildGradleFile.withWriter {
			BufferedWriter bufferedWriter ->

			contents.each {
				bufferedWriter.writeLine it
			}
		}
	}

	readLegacyXmls()

	writeBuildGradleFile()
}

war {
	Closure getLanguageProperties
	Closure getNewDependencyNames
	Closure setManifest

	destinationDir = file("${rootDir}/dist2")

	duplicatesStrategy "exclude"

	exclude "WEB-INF/lib/*"

	filesMatching("WEB-INF/liferay-hook.xml") {
		filter {
			line ->

			line.contains("content/Language*.properties") ? getLanguageProperties() : line
		}
	}

	getLanguageProperties = {
		StringBuilder sb = new StringBuilder()

		File contentDir = file("${pluginSrcDir}/content")

		File[] files = contentDir.listFiles()

		for (int i = 0; i < files.length; i++) {
			File file = files[i]

			sb << "\t<language-properties>content/" + file.name + "</language-properties>"

			if ((i + 1) < files.length) {
				sb << "\n"
			}
		}

		return sb.toString()
	}

	getNewDependencyNames = {
		configurations.compile.resolvedConfiguration.resolvedArtifacts.collectEntries {
			ModuleVersionIdentifier moduleVersionIdentifier = it.moduleVersion.id

			[(String)"${moduleVersionIdentifier.name}-${moduleVersionIdentifier.version}.jar", (String)"${moduleVersionIdentifier.name}.jar"]
		}
	}.memoize()

	setManifest = {
		File manifestFile

		if (osgiPlugin) {
			manifestFile = file("src/META-INF/MANIFEST.MF")
		}
		else {
			manifestFile = file("docroot/META-INF/MANIFEST.MF")
		}

		if (manifestFile.exists()) {
			manifest.from manifestFile
		}
		else {
			CopySpec copySpec = rootSpec.children.find {
				CopySpecResolver copySpecResolver = it.buildRootResolver()

				copySpecResolver.destPath.pathString == "META-INF"
			}

			if (copySpec) {
				copySpec.exclude "**"
			}
		}
	}

	outputs.file archivePath

	rootSpec.children*.rename {
		String fileName ->

		Map<String, String> newDependencyNames = getNewDependencyNames();

		return newDependencyNames[fileName] ?: fileName
	}

	setManifest()
}