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 {
	dependencies {
		classpath group: "com.liferay", name: "com.liferay.gradle.plugins.defaults", version: "latest.release"
	}

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

task buildChangelogs
task recordCommits

buildChangelogs {
	dependsOn recordCommits

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

	doLast {
		File changelogCommitsFile = file("CHANGELOG.commits")

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

		String text = "# Liferay Blade CLI Change Log"

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

		File changelogDescriptionsFile = file("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}", "--", ".", ":(exclude,glob)**/CHANGELOG.*"
				standardOutput = standardOutputByteArrayOutputStream
			}

			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(".*[Pp]rep next.*") &&
							!commitMessage.matches(".*[Pp]repare.*") &&
							!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}", "--", "cli/build.gradle"]

				commandLine commandLineArgs
				standardOutput = standardOutputByteArrayOutputStream
			}

			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
			}

			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("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 {

		ByteArrayOutputStream standardOutputByteArrayOutputStream = new ByteArrayOutputStream()

		exec {
			commandLine "git", "--no-pager", "log", "--date=rfc2822", "--format=fuller", "-p"
			standardOutput = standardOutputByteArrayOutputStream
		}

		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 fileName1, String fileName2 ->

			String[] diffFiles = diff.split("\ndiff --git ")

			for (String diffFile : diffFiles) {
				if (diffFile.startsWith("a/" + fileName1 + " b/" + fileName1)) {
					Matcher matcher = diffFile =~ /\n\+version = "(\d+\.\d+\.\d+)"\n/

					String version = null

					if (matcher.find()) {
						version = matcher.group(1)

						return VersionNumber.parse(version)
					}
				}

				if (diffFile.startsWith("a/" + fileName2 + " b/" + fileName2)) {
					Matcher matcher = diffFile =~ /\n-base-version: *(\d+\.\d+\.\d+)\n/

					String version = null

					if (matcher.find()) {
						version = matcher.group(1)

						return VersionNumber.parse(version)
					}
				}

			}

			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], "cli/build.gradle", "cnf/build.bnd")

			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.matches(".*[Pp]rep next.*") && !previousCommitMessage.matches(".*[Pp]repare.*")) || (getPublishedVersionNumberClosure(lines[7], "cli/build.gradle", "cnf/build.bnd") != 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("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))
}