Merge branch 'main' into dependabot/maven/maven-plugins-9739a93c2e

Author: niklasga

.changeset/dependabot-0596f93.md

@@ -0,0 +1,5 @@
+---
+"changesets": patch
+---
+
+- org.junit.jupiter:junit-jupiter-api, org.junit.jupiter:junit-jupiter-params: 

.changeset/dependabot-4fb901f.md

@@ -0,0 +1,5 @@
+---
+"changesets": patch
+---
+
+- com.fasterxml.jackson.dataformat:jackson-dataformat-yaml: 

.changeset/dependabot-ba06d2e.md

@@ -0,0 +1,5 @@
+---
+"changesets": patch
+---
+
+- org.semver4j:semver4j: 

.changeset/legal-parents-scream.md

@@ -0,0 +1,7 @@
+---
+"changesets": minor
+---
+
+Add support for handling dependency updates separately from other changesets, so that they can be presented in a more organised way.
+
+This is utilized by setting the update type to `dependency` in place of major/minor/patch.

README.md

@@ -8,6 +8,22 @@ users recognize the ways of working and feel at home.
 
 This is it, at the moment. Stay tuned for more docs later on, thanks!
 
+## Dependency updates
+Due to the way automated dependency update bots like Dependabot and Renovate work, there is often a large influx of automated changesets that are not easy to merge into the normal changelog. They can also be the source of an unwanted amount of noise in the changelog.
+
+To help with this, we have added a feature to mark changesets as dependency update using the update type "dependency". This will make the changeset appear in a separate section in the changelog, and will be added as a single list of updates in the end of the released version.
+
+Dependencies that have been updated to new versions multiple times between releases will have each of the updates listed in the changelog.
+
+```
+---
+"changesets-java": dependency
+---
+
+- ch.qos.logback:logback-core: 1.5.12
+- com.google.errorprone:error_prone_annotations: 2.34.0
+```
+
 ## Release Maven Plugin Integration
 
 To delegate versioning to the Release Maven Plugin, you can use the `ChangesetsVersionPolicy` together with the `useReleasePluginIntegration` flag:

changesets-java/src/main/java/se/fortnox/changesets/ChangelogAggregator.java

@@ -19,6 +19,7 @@
 import static java.util.stream.Collectors.toList;
 import static org.slf4j.LoggerFactory.getLogger;
 import static se.fortnox.changesets.ChangesetWriter.CHANGESET_DIR;
+import static se.fortnox.changesets.Level.DEPENDENCY;
 import static se.fortnox.changesets.Level.MAJOR;
 import static se.fortnox.changesets.Level.MINOR;
 import static se.fortnox.changesets.Level.PATCH;
@@ -27,9 +28,15 @@ public class ChangelogAggregator {
 	private static final Logger LOG = getLogger(ChangelogAggregator.class);
 	public static final String CHANGELOG_FILE = "CHANGELOG.md";
 	private final Path baseDir;
+	private final DependencyUpdatesParser dependencyUpdatesParser;
 
 	public ChangelogAggregator(Path baseDir) {
+		this(baseDir, new DependencyUpdatesParser());
+	}
+
+	public ChangelogAggregator(Path baseDir, DependencyUpdatesParser dependencyUpdatesParser) {
 		this.baseDir = baseDir;
+		this.dependencyUpdatesParser = dependencyUpdatesParser;
 	}
 
 	/**
@@ -38,23 +45,26 @@ public ChangelogAggregator(Path baseDir) {
 	 *
 	 * @param packageName The package name to get changesets for
 	 * @param version     The version number of the merged changes
+	 * @return
 	 */
-	public void mergeChangesetsToChangelog(String packageName, String version) {
+	public Path mergeChangesetsToChangelog(String packageName, String version) {
 		Path changesetsDir = this.baseDir.resolve(CHANGESET_DIR);
 
 		ChangesetLocator changesetLocator = new ChangesetLocator(this.baseDir);
 		List<Changeset> changesets = changesetLocator.getChangesets(packageName);
 		if (changesets.isEmpty()) {
 			LOG.info("No changesets found in {}", this.baseDir);
-			return;
+			return changesetsDir;
 		}
 
 		String changelog = generateChangelog(packageName, version, changesets);
 
+		Path changelogFile;
 		try {
-			writeChangelog(changelog);
+			changelogFile = writeChangelog(changelog);
 		} catch (ChangelogException exception) {
 			LOG.error("Failed to update changelog at {}", changesetsDir, exception);
+			return changesetsDir;
 		}
 
 		changesets.forEach(changeset -> {
@@ -65,26 +75,25 @@ public void mergeChangesetsToChangelog(String packageName, String version) {
 				LOG.error("Failed to delete {}", file, e);
 			}
 		});
+		return changelogFile;
 	}
 
-	private static String generateChangelog(String packageName, String version, List<Changeset> changesets) {
+	private String generateChangelog(String packageName, String version, List<Changeset> changesets) {
 		String changes = changesets
 			.stream()
 			.collect(groupingBy(Changeset::level, mapping(Changeset::message, toList())))
 			.entrySet()
 			.stream()
 			.sorted(sortChangesets())
 			.map(entry -> {
-				String level = entry.getKey().getPresentationString();
-				String levelChanges = entry.getValue().stream()
-					.map(ChangelogAggregator::formatChangeAsBulletPoint)
-					.sorted()
-					.collect(Collectors.joining("\n"));
+				Level level = entry.getKey();
+				String levelString = level.getPresentationString();
+				String levelChanges = formatChangeset(level, entry.getValue());
 
 				return """
-					### %s Changes
+					### %s
 					
-					%s""".formatted(level, levelChanges);
+					%s""".formatted(levelString, levelChanges);
 			})
 			.collect(Collectors.joining("\n\n"));
 
@@ -99,6 +108,23 @@ private static String generateChangelog(String packageName, String version, List
 		return MarkdownFormatter.format(markdown);
 	}
 
+	private String formatChangeset(Level level, List<String> changes) {
+		if (level == DEPENDENCY) {
+			// Extract all dependencies from each dependency change and put them into a single list
+			return changes.stream()
+				.flatMap(change -> dependencyUpdatesParser.parseDependencyChangeset(change).stream())
+				.map(ChangelogAggregator::formatChangeAsBulletPoint)
+				.distinct()
+				.sorted()
+				.collect(Collectors.joining("\n"));
+		}
+
+		return changes.stream()
+			.map(ChangelogAggregator::formatChangeAsBulletPoint)
+			.sorted()
+			.collect(Collectors.joining("\n"));
+	}
+
 	private static String formatChangeAsBulletPoint(String change) {
 		// Add the change as a bullet point, with leading dash and each subsequent line indented with two spaces
 		String firstLinePrefix = "- ";
@@ -118,7 +144,7 @@ private static String formatChangeAsBulletPoint(String change) {
 	}
 
 	private static Comparator<Map.Entry<Level, List<String>>> sortChangesets() {
-		List<Level> levelOrder = List.of(MAJOR, MINOR, PATCH);
+		List<Level> levelOrder = List.of(MAJOR, MINOR, PATCH, DEPENDENCY);
 
 		return (o1, o2) -> {
 			// Sort levels in the order specified in levelOrder
@@ -135,9 +161,10 @@ private static Comparator<Map.Entry<Level, List<String>>> sortChangesets() {
 	 * If the file already exists, trim the first header before prepending it with the new changelog entries.
 	 *
 	 * @param changelog The new changelog content
+	 * @return
 	 * @throws ChangelogException Thrown if file operations on the existing or new file are unsuccessful
 	 */
-	private void writeChangelog(String changelog) throws ChangelogException {
+	private Path writeChangelog(String changelog) throws ChangelogException {
 		Path changelogFile = this.baseDir.resolve(CHANGELOG_FILE);
 
 		if (Files.exists(changelogFile)) {
@@ -146,6 +173,7 @@ private void writeChangelog(String changelog) throws ChangelogException {
 
 		try {
 			Files.writeString(changelogFile, changelog, TRUNCATE_EXISTING, CREATE);
+			return changelogFile;
 
 		} catch (IOException e) {
 			throw new ChangelogException("Failed to write " + changelogFile, e);

changesets-java/src/main/java/se/fortnox/changesets/ChangesetParser.java

@@ -36,6 +36,7 @@ public static List<Changeset> parseFile(File file) {
 
 				// Translate to enum
 				Level level = switch (levelString) {
+					case "dependency" -> Level.DEPENDENCY;
 					case "patch" -> Level.PATCH;
 					case "minor" -> Level.MINOR;
 					case "major" -> Level.MAJOR;

changesets-java/src/main/java/se/fortnox/changesets/DependencyUpdatesParser.java

@@ -0,0 +1,42 @@
+package se.fortnox.changesets;
+
+import com.vladsch.flexmark.ast.Paragraph;
+import com.vladsch.flexmark.parser.Parser;
+import com.vladsch.flexmark.util.ast.Document;
+import com.vladsch.flexmark.util.ast.Node;
+import com.vladsch.flexmark.util.collection.iteration.ReversiblePeekingIterable;
+import org.slf4j.Logger;
+
+import java.util.List;
+import java.util.stream.StreamSupport;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+public class DependencyUpdatesParser {
+	private static final Logger LOG = getLogger(DependencyUpdatesParser.class);
+
+	public List<String> parseDependencyChangeset(String change) {
+		Parser parser = Parser.builder().build();
+		Document parsed = parser.parse(change);
+
+		if (!parsed.hasChildren()) {
+			return List.of();
+		}
+
+		String nodeName = parsed.getFirstChild().getNodeName();
+		if (!nodeName.equals("BulletList")) {
+			LOG.warn("Unexpected node type {}", nodeName);
+			return List.of();
+		}
+
+		ReversiblePeekingIterable<Node> dependencyNodes = parsed.getFirstChild().getChildren();
+
+		return StreamSupport.stream(dependencyNodes.spliterator(), false)
+			.map(node -> {
+				Paragraph paragraph = (Paragraph)node.getChildOfType(Paragraph.class);
+				return paragraph.getChars().toString().trim();
+			})
+			.distinct()
+			.toList();
+	}
+}

changesets-java/src/main/java/se/fortnox/changesets/Level.java

@@ -1,9 +1,10 @@
 package se.fortnox.changesets;
 
 public enum Level {
-	MAJOR("major", "Major"),
-	MINOR("minor", "Minor"),
-	PATCH("patch", "Patch");
+	MAJOR("major", "Major Changes"),
+	MINOR("minor", "Minor Changes"),
+	PATCH("patch", "Patch Changes"),
+	DEPENDENCY("dependency", "Dependency Updates");
 
 	private final String textValue;
 	private final String presentationString;

changesets-java/src/main/java/se/fortnox/changesets/MarkdownFormatter.java

@@ -20,7 +20,14 @@ public class MarkdownFormatter {
 	public static String format(String markdown) {
 		MutableDataSet formatOptions = new MutableDataSet();
 		// Clean up whitespaces in different ways
-		formatOptions.set(FORMAT_FLAGS, LineAppendable.F_FORMAT_ALL);
+		// Do not use F_TRIM_TRAILING_WHITESPACE as it is required for line breaks in bullet lists
+		int format = LineAppendable.F_CONVERT_TABS |
+			// LineAppendable.F_COLLAPSE_WHITESPACE;
+			// LineAppendable.F_TRIM_TRAILING_WHITESPACE |
+			LineAppendable.F_TRIM_LEADING_WHITESPACE |
+			LineAppendable.F_TRIM_LEADING_EOL
+				;
+		formatOptions.set(FORMAT_FLAGS, format);
 
         // Limit line lengths
 		formatOptions.set(RIGHT_MARGIN, 120);