build.gradle

buildscript {
	dependencies {
		classpath group: "net.diibadaaba.zipdiff", name: "zipdiff", version: "1.0"
	}
	repositories {
		mavenCentral()
	}
}

import net.diibadaaba.zipdiff.DifferenceCalculator
import net.diibadaaba.zipdiff.Differences
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry

FileTree bndtoolsBundles = fileTree(dir: 'bndtools', include: '**/dist/bundles/**/*.jar', exclude: '**/*latest.jar')
FileTree gradleBundles = fileTree(dir: 'gradle', include: '**/libs/*.jar')
FileTree liferayGradleBundles = fileTree(dir: 'liferay-gradle', include: '**/libs/*.jar')
FileTree liferayWorkspaceBundles = fileTree(dir: 'liferay-workspace/modules', include: '**/libs/*.jar')
FileTree mavenBundles = fileTree(dir: 'maven', include: '**/target/*.jar')

int canonicalBundlesSize = liferayGradleBundles.size()

task bundlesSizeTest << {
	assert canonicalBundlesSize == bndtoolsBundles.size()
	assert canonicalBundlesSize == gradleBundles.size()
	assert canonicalBundlesSize == liferayWorkspaceBundles.size()
	assert canonicalBundlesSize == mavenBundles.size()
}

FileTree gradleWars = fileTree(dir: 'gradle', include: '**/libs/*.war')
FileTree liferayWorkspaceWars = fileTree(dir: 'liferay-workspace/wars', include: '**/libs/*.war')
FileTree liferayGradleWars = fileTree(dir: 'liferay-gradle', include: '**/libs/*.war')
FileTree mavenWars = fileTree(dir: 'maven', include: '**/target/*.war')

int canonicalWarsSize = liferayGradleWars.size()

task warsSizeTest << {
	assert canonicalWarsSize == gradleWars.size()
	assert canonicalWarsSize == liferayGradleWars.size()
	assert canonicalWarsSize == liferayWorkspaceWars.size()
	assert canonicalWarsSize == mavenWars.size()
}

task bundlesSortTest << {
	def fileNamesDiff = liferayGradleBundles.files.name.sort() - gradleBundles.files.name.sort()
	assert [] == fileNamesDiff : "liferay-gradle vs gradle"

	fileNamesDiff = liferayGradleBundles.files.name.sort() - bndtoolsBundles.files.name.sort()
	assert [] == fileNamesDiff : "liferay-gradle vs bndtools"

	fileNamesDiff = liferayGradleBundles.files.name.sort() - liferayWorkspaceBundles.files.name.sort()
	assert [] == fileNamesDiff : "liferay-gradle vs liferay-workspace"

	fileNamesDiff = liferayGradleBundles.files.name.sort() - mavenBundles.files.name.sort()
	assert [] == fileNamesDiff : "liferay-gradle vs maven"
}

task bundlesTest << {}

bundlesTest.dependsOn bundlesSizeTest
bundlesTest.dependsOn bundlesSortTest

task warsTest << {}

warsTest.dependsOn warsSizeTest

task replicateSources << {
	Closure projectFilter = {
		it.isDirectory() && it.name.startsWith("blade") && !it.name.matches("\\..*")
	}

	def canonicalSource

	if (project.hasProperty('sourceProjectProp')) {
		canonicalSource = sourceProjectProp
	}
	else {
		canonicalSource = 'liferay-gradle'
	}

	def canonicalProjects = file(canonicalSource).listFiles().findAll(projectFilter)
	def replicationParents = files(['bndtools', 'gradle', 'liferay-gradle', 'liferay-workspace/modules', 'maven'] - canonicalSource)

	canonicalProjects.each { canonicalProject ->
		if ((new File(canonicalProject, "bnd.bnd").exists())) {
			replicationParents.each { replicationParent ->
				def replicationProjects = replicationParent.listFiles().findAll(projectFilter)

				def replicationProject = replicationProjects.find{ it.name == canonicalProject.name }

				if (replicationProject == null) {
					replicationProject = new File(replicationParent, canonicalProject.name)
					replicationProject.mkdirs()

					def buildFilesProject = new File(replicationParent, "blade.portlet.jsp")

					ant.copy(todir: replicationProject) {
						fileset(dir: buildFilesProject, includes: "*")
					}
				}

				ant.copy(todir: replicationProject) {
					fileset(dir: canonicalProject, includes: "*.markdown")
				}

				def replicationSrc = new File( replicationProject, 'src/' )

				replicationSrc.deleteDir()

				def canonicalSrc = new File( canonicalProject, 'src/' )

				ant.copy(todir: replicationSrc) {
					fileset(dir: canonicalSrc, includes: "**")
				}
			}
		}
	}
}

configurations {
	bnd
}

dependencies {
	bnd group: "biz.aQute.bnd", name: "biz.aQute.bnd", version: "3.1.0"
}

repositories {
	mavenCentral()
}

task bundlesDiffTest << {
	def errorList = []

	[bndtoolsBundles, gradleBundles, liferayWorkspaceBundles, mavenBundles].each { replicationFiles ->
		replicationFiles.each { replicationFile ->

			def liferayGradleOutputFile = liferayGradleBundles.find {
				it.name == replicationFile.name
			}

			String exclusions = "*pom.properties, *pom.xml, Archiver-Version, Built-By, Build-Jdk, Javac-Debug, Javac-Deprecation, Javac-Encoding"

			def os = new ByteArrayOutputStream()

			javaexec {
				args "diff", "-i", "${exclusions}", replicationFile, liferayGradleOutputFile

				classpath = configurations.bnd
				main = "aQute.bnd.main.bnd"
				standardOutput = os
			}

			def errorOutput = os.toString()

			if (errorOutput) {
				errorList.add("${replicationFiles} - ${replicationFile.name} \n" + errorOutput)
			}
		}
	}

		if (!errorList.empty) {
		throw new GradleException(errorList.toListString())
	}
}

task warsDiffTest << {
	[gradleWars, liferayWorkspaceWars, mavenWars].each { replicationWars ->
		replicationWars.each { replicationWar ->

			def liferayGradleWar = liferayGradleWars.find {
				it.name == replicationWar.name.replaceAll("-1.0.0", "")
			}

			DifferenceCalculator differenceCalculator = new DifferenceCalculator(
				replicationWar, liferayGradleWar)

			differenceCalculator.setFilenameRegexToIgnore(
				Collections.singleton(".*META-INF.*"))
			differenceCalculator.setIgnoreTimestamps(true)

			Differences differences = differenceCalculator.getDifferences()

			if (differences.hasDifferences()) {
				boolean realChange = false

				def added = differences.getAdded()
				def changed = differences.getChanged()
				def removed = differences.getRemoved()

				if (added.isEmpty() && !changed.isEmpty() && removed.isEmpty()) {
					for (String change : changed.keySet()) {
						ZipArchiveEntry[] zipArchiveEntries = changed.get(change);

						ZipArchiveEntry zipArchiveEntry1 = zipArchiveEntries[0];
						ZipArchiveEntry zipArchiveEntry2 = zipArchiveEntries[0];

						if (zipArchiveEntry1.isDirectory() &&
								zipArchiveEntry2.isDirectory() &&
								(zipArchiveEntry1.getSize() ==
									zipArchiveEntry2.getSize()) &&
								(zipArchiveEntry1.getCompressedSize() <= 2) &&
								(zipArchiveEntry2.getCompressedSize() <= 2)) {

							// Skip zipdiff bug

							continue;
						}

						realChange = true;

						break;
					}
				}
				else {
						realChange = true;
				}

				if (realChange) {
					throw new GradleException(
						"WAR " + replicationWar + " and " + liferayGradleWar + " do not match:\n" +
							differences)
				}
			}
		}
	}
}

task diff << {}

diff.dependsOn bundlesDiffTest
diff.dependsOn warsDiffTest