changelogs-sdk.gradle

import com.liferay.gradle.util.Validator

import groovy.time.TimeCategory
import groovy.time.TimeDuration

import java.util.regex.Matcher

import org.gradle.util.GUtil
import org.gradle.util.VersionNumber

buildscript {
	apply from: file("build-buildscript.gradle"), to: buildscript

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

task buildChangelogs
task recordCommits

File sdkDir = file("sdk")

buildChangelogs {
	dependsOn recordCommits

	description = "Builds the changelogs for each published version in 'CHANGELOG.markdown'."
	group = "changelogs"

	doLast {
		sdkDir.eachDir {
			File sdkProjectDir ->

			if (project.properties["projectName"] && (project.properties["projectName"] != sdkProjectDir.name)) {
				return
			}

			if (sdkProjectDir.name == "project-templates") {
				return
			}

			File changelogCommitsFile = file("sdk/" + sdkProjectDir.name + "/CHANGELOG.commits")

			if (!changelogCommitsFile.exists()) {
				return
			}

			String text = "# " + GUtil.loadProperties(new File(sdkDir, sdkProjectDir.name + "/bnd.bnd"))["Bundle-Name"] + " Change Log"

			String commitRange = ""
			List<String> ticketNumbers = []
			String version = ""

			File changelogDescriptionsFile = file("sdk/" + sdkProjectDir.name + "/CHANGELOG.descriptions")

			changelogCommitsFile.getText("UTF-8").split("\n").each {
				String recordCommitLine ->

				Matcher matcher = recordCommitLine =~ /(\d+\.\d+\.\d+):([a-f0-9]+\.\.[a-f0-9]+)/

				if (matcher.find()) {
					commitRange = matcher.group(2)
					version = matcher.group(1)
				}

				ByteArrayOutputStream standardOutputByteArrayOutputStream = new ByteArrayOutputStream()

				exec {
					commandLine "git", "--no-pager", "log", "--pretty=format:%H:%cd:%s", "--date=short", "${commitRange}", "--", "modules/sdk/" + sdkProjectDir.name, ":(exclude,glob)**/CHANGELOG.*"
					standardOutput = standardOutputByteArrayOutputStream
					workingDir = projectDir.parentFile
				}

				String gitLogOutput = standardOutputByteArrayOutputStream.toString()

				Closure<Void> getGitLogAttributes = {
					String gitLogLine ->

					String commitMessage = ""
					String sha = ""
					String ticketNumber = ""

					Matcher gitLogMatcher = gitLogLine =~ /([a-f0-9]+):.+:((?:.*?)(?<![A-Z])(?:[A-Z]+-\d+(?:[^A-Za-z0-9]+[A-Z]+-\d+)*))(.*)/

					if (gitLogMatcher.find()) {
						commitMessage = gitLogMatcher.group(3)
						sha = gitLogMatcher.group(1)
						ticketNumber = gitLogMatcher.group(2)
					}

					if (ticketNumber.startsWith("Revert \"")) {
						commitMessage = ticketNumber + commitMessage

						ticketNumber = ticketNumber.substring(8)
					}

					return ["SHA" : sha, "TICKET-NUMBER" : ticketNumber.replaceAll(".*?([A-Z]+-\\d+.*)", "\$1"), "COMMIT-MESSAGE" : commitMessage]
				}

				String commits = ""

				gitLogOutput.eachLine {
					String gitLogLine ->

					Map<String, String> gitLogAttributes = getGitLogAttributes(gitLogLine)

					String sha = gitLogAttributes["SHA"]

					if (Validator.isNotNull(sha)) {
						String commitMessage = gitLogAttributes["COMMIT-MESSAGE"].trim()

						if (!commitMessage.equalsIgnoreCase("Auto SF") &&
							!commitMessage.equalsIgnoreCase("SF") &&
							!commitMessage.matches(".*Prep next.*") &&
							!commitMessage.matches(".*prep enxt.*") &&
							!commitMessage.matches(".*prep next.*") &&
							!commitMessage.matches(".*[Uu]se (\\d+\\.\\d+\\.\\d+|latest).*") &&
							!commitMessage.matches("Revert \".* SF\"") &&
							!commitMessage.startsWith("Semver")) {

							String ticketMarkdown = gitLogAttributes["TICKET-NUMBER"].replaceAll("([A-Z]+-\\d+)", "[\$1]")

							commits = commits + "\n" + _format("- " + ticketMarkdown + " " + commitMessage + " (" + sha.substring(0, 10) + ")")

							ticketNumbers.add(gitLogAttributes["TICKET-NUMBER"])
						}
					}
				}

				String dependencies = ""

				standardOutputByteArrayOutputStream = new ByteArrayOutputStream()

				exec {
					List<String> commandLineArgs = ["git", "--no-pager", "log", "--pretty=format:%H:%cd:%s", "--date=short", "-p", "${commitRange}", "--", "modules/sdk/" + sdkProjectDir.name + "/build.gradle"]

					if (sdkProjectDir.name == "gradle-plugins") {
						commandLineArgs.add("modules/sdk/" + sdkProjectDir.name + "/src/main/resources/com/liferay/gradle/plugins/dependencies/portal-tools.properties")
					}

					commandLine commandLineArgs
					standardOutput = standardOutputByteArrayOutputStream
					workingDir = projectDir.parentFile
				}

				gitLogOutput = standardOutputByteArrayOutputStream.toString()

				Map<String, String> gitLogAttributes = [:]

				gitLogOutput.eachLine {
					String gitLogLine ->

					if (gitLogLine ==~ /([a-f0-9]+):.+:(.*)/) {
						gitLogAttributes = getGitLogAttributes(gitLogLine)
					}
					else {
						matcher = gitLogLine =~ /^\+\s*.+ group: .*, name: \"(.+)", .*version: \"(.*)\"/

						if (!matcher.find()) {
							matcher = gitLogLine =~ /^\+([^ \t]+)=([0-9.]+)/

							if (!matcher.find()) {
								return
							}
						}

						String dependencyName = matcher.group(1)
						String dependencyVersion = matcher.group(2)

						dependencies = dependencies + "\n" + _format("- [" + gitLogAttributes["TICKET-NUMBER"] + "] Update the " + dependencyName + " dependency to version " + dependencyVersion + ".")

						ticketNumbers.add(gitLogAttributes["TICKET-NUMBER"])
					}
				}

				String descriptions = ""

				if (changelogDescriptionsFile.exists()) {

					String escapedDotVersion = version.replace(".", "\\.")

					matcher = changelogDescriptionsFile.text =~ /(?s)${escapedDotVersion}:description(.+?)(?:(?=\d+\.\d+\.\d+:description)|$)/

					if (matcher.find()) {
						descriptions = "\n" + matcher.group(1).trim()
					}
				}

				String endRange = commitRange.split("\\.\\.")[1]

				standardOutputByteArrayOutputStream = new ByteArrayOutputStream()

				exec {
					commandLine "git", "log", "-1", "--pretty=format:%H:%cd:%s", "--date=short", "${endRange}"
					standardOutput = standardOutputByteArrayOutputStream
					workingDir = projectDir.parentFile
				}

				String publishDate = standardOutputByteArrayOutputStream.toString().split(":")[1]

				if ((commits.length() > 0) || (dependencies.length() > 0) || (descriptions.length() > 0)) {
					text += """\
						|
						|
						|## ${version} - ${publishDate}""".stripMargin()
				}

				if (commits.length() > 0) {
					text += """\
						|
						|
						|### Commits""".stripMargin()

					text += commits
				}

				if (dependencies.length() > 0) {
					text += """\
						|
						|
						|### Dependencies""".stripMargin()

					text += dependencies
				}

				if (descriptions.length() > 0) {
					text += """\
						|
						|
						|### Description""".stripMargin()

					text += descriptions
				}
			}

			if (ticketNumbers.size > 0) {
				text += """\
					|
					|""".stripMargin()

				Matcher matcher = ticketNumbers =~ /([A-Z]+-\d+)/

				List<String> tickets = []

				while (matcher.find()) {
					tickets.add(matcher.group(1))
				}

				tickets = tickets.flatten().unique().sort{
					ticket1, ticket2 ->

					String ticketType1 = ticket1.substring(0, ticket1.indexOf("-"))
					String ticketType2 = ticket2.substring(0, ticket2.indexOf("-"))

					String ticketNumber1 = ticket1.substring(ticket1.indexOf("-") + 1)
					String ticketNumber2 = ticket2.substring(ticket2.indexOf("-") + 1)

					if (ticketType1 == ticketType2) {
						return Integer.valueOf(ticketNumber1) - Integer.valueOf(ticketNumber2)
					}

					return ticketType1.compareTo(ticketType2)
				}

				tickets.each {
					String ticket ->

					text += "\n[" + ticket + "]: https://issues.liferay.com/browse/" + ticket
				}
			}

			File changelogMarkdownFile = file("sdk/" + sdkProjectDir.name + "/CHANGELOG.markdown")

			changelogMarkdownFile.text = text

			logger.lifecycle "Updated '{}'", changelogMarkdownFile
		}
	}
}

recordCommits {
	description = "Records the commit ID for each published version in 'CHANGELOG.commits'."
	group = "changelogs"

	doLast {
		sdkDir.eachDir {
			File sdkProjectDir ->

			if (project.properties["projectName"] && (project.properties["projectName"] != sdkProjectDir.name)) {
				return
			}

			if (sdkProjectDir.name == "project-templates") {
				return
			}

			ByteArrayOutputStream standardOutputByteArrayOutputStream = new ByteArrayOutputStream()

			exec {
				commandLine "git", "--no-pager", "log", "--date=rfc2822", "--format=fuller", "-p", "--", "modules/sdk/" + sdkProjectDir.name + "/"
				standardOutput = standardOutputByteArrayOutputStream
				workingDir = projectDir.parentFile
			}

			String gitLogOutput = standardOutputByteArrayOutputStream.toString()

			List<String> commits = []

			if (Validator.isNotNull(gitLogOutput)) {
				String text = gitLogOutput

				if (text.startsWith("commit ")) {
					text = text.substring(7)
				}

				commits = text.split("\ncommit ")
			}

			String lastVersionCommitId = null
			VersionNumber lastVersionNumber = null
			Map<VersionNumber, String> recordCommitIDs = [:]

			Closure<Void> getPublishedVersionNumberClosure = {
				String diff, String projectName ->

				int x = diff.indexOf("/" + projectName + "/bnd.bnd");
				int y = diff.indexOf("-Bundle-Version: ", x)

				if ((x != -1) && (y != -1)) {
					return VersionNumber.parse(diff.substring(y + 17, diff.indexOf("\n", y)))
				}

				return null
			}

			for (int i = 0; i < (commits.size() - 1); i++) {
				String commit = commits.get(i)

				String[] lines = commit.split("\n", 8)

				VersionNumber publishedVersionNumber = getPublishedVersionNumberClosure(lines[7], sdkProjectDir.name)

				if ((publishedVersionNumber != null) && !recordCommitIDs.containsKey(publishedVersionNumber) && (publishedVersionNumber.major > 0) && ((lastVersionNumber == null) || (publishedVersionNumber.compareTo(lastVersionNumber) < 0))) {
					String commitDateString = lines[4]
					String commitId = lines[0]

					Date commitDate = Date.parse("E, d MMM yyyy H:m:s Z", commitDateString.substring(12))

					for (int j = i - 1; j >= 0; j--) {
						String previousCommit = commits.get(j)

						lines = previousCommit.split("\n", 8)

						String previousCommitMessage = lines[6]

						if (!previousCommitMessage.contains("prep next") || (getPublishedVersionNumberClosure(lines[7], sdkProjectDir.name) != null)) {
							break
						}

						String previousCommitDateString = lines[4]

						Date previousCommitDate = Date.parse("E, d MMM yyyy H:m:s Z", previousCommitDateString.substring(12))

						TimeDuration duration = TimeCategory.minus(previousCommitDate, commitDate)

						if (duration.toMilliseconds() > 1800000) {
							break
						}

						commitId = lines[0]
					}

					if (lastVersionNumber != null) {
						recordCommitIDs.put(lastVersionNumber, commitId + ".." + lastVersionCommitId)
					}

					lastVersionCommitId = commitId
					lastVersionNumber = publishedVersionNumber
				}
			}

			if (recordCommitIDs.size() <= 0) {
				return
			}

			File changelogCommitsFile = file("sdk/" + sdkProjectDir.name + "/CHANGELOG.commits")

			changelogCommitsFile.text = recordCommitIDs.collect {
				VersionNumber versionNumber, String commitIds ->

				"${versionNumber}:${commitIds}"
			} join "\n"

			logger.lifecycle "Updated '{}'", changelogCommitsFile
		}
	}
}

private String _format(String line) {
	String formattedLine = line.replaceAll("[ \t]{2,}", " ")

	if (formattedLine.length() <= 80) {
		return formattedLine
	}

	int x = formattedLine.indexOf(" ")

	if (x == -1) {
		return formattedLine
	}

	if (x > 80) {
		return formattedLine.substring(0, x) + "\n" + _format(formattedLine.substring(x + 1))
	}

	x = formattedLine.lastIndexOf(" ", 80)

	return formattedLine.substring(0, x) + "\n" + _format(formattedLine.substring(x + 1))
}