From 2b06aa7f4c9c4ec97b328fe2ce8f45fc4b8499d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Tue, 29 Aug 2023 17:43:09 +0200 Subject: [PATCH 1/8] WIP --- .../sbm/parsers/BuildFileParser.java | 37 +---------- .../RewriteMavenPomCacheConfiguration.java | 65 +++++++++++++++++++ .../sbm/parsers/RewriteProjectParser.java | 2 +- 3 files changed, 68 insertions(+), 36 deletions(-) create mode 100644 sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java index 9233c3e7d..e0475e286 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java @@ -52,6 +52,7 @@ class BuildFileParser { private final ParserSettings parserSettings; + private final MavenPomCache mavenPomCache; /** * Parse a list of Maven Pom files to a Map of {@code Path} and their parsed {@link Xml.Document}s. @@ -99,8 +100,7 @@ public Map parseBuildFiles( if (parserSettings.isPomCacheEnabled()) { //The default pom cache is enabled as a two-layer cache L1 == in-memory and L2 == RocksDb //If the flag is set to false, only the default, in-memory cache is used. - MavenPomCache pomCache = getPomCache(); - MavenExecutionContextView.view(executionContext).setPomCache(pomCache); + MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); } // 395 : 398 @@ -168,39 +168,6 @@ private List parsePoms(Path baseDir, List pomFiles, MavenP return mavenParserBuilder.build().parseInputs(pomFileInputs, baseDir, executionContext).toList(); } - /** - * {@link MavenMojoProjectParser##getPomCache()} - */ - private static MavenPomCache getPomCache() { -// if (pomCache == null) { -// if (isJvm64Bit()) { -// try { -// if (pomCacheDirectory == null) { -// //Default directory in the RocksdbMavenPomCache is ".rewrite-cache" -// pomCache = new CompositeMavenPomCache( -// new InMemoryMavenPomCache(), -// new RocksdbMavenPomCache(Paths.get(System.getProperty("user.home"))) -// ); -// } else { -// pomCache = new CompositeMavenPomCache( -// new InMemoryMavenPomCache(), -// new RocksdbMavenPomCache(Paths.get(pomCacheDirectory)) -// ); -// } -// } catch (Exception e) { -// logger.warn("Unable to initialize RocksdbMavenPomCache, falling back to InMemoryMavenPomCache"); -// logger.debug(e); -// } -// } else { -// logger.warn("RocksdbMavenPomCache is not supported on 32-bit JVM. falling back to InMemoryMavenPomCache"); -// } -// } -// if (pomCache == null) { - MavenPomCache pomCache = new InMemoryMavenPomCache(); -// } - return pomCache; - } - private void initializeMavenSettings(ExecutionContext executionContext) { } diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java new file mode 100644 index 000000000..acf20d943 --- /dev/null +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java @@ -0,0 +1,65 @@ +/* + * Copyright 2021 - 2022 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.sbm.parsers; + +import jdk.jfr.Enabled; +import org.openrewrite.ExecutionContext; +import org.openrewrite.maven.MavenExecutionContextView; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; +import org.openrewrite.maven.cache.MavenPomCache; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * @author Fabian Krüger + */ +@Configuration +public class RewriteMavenPomCacheConfiguration { + @Bean + MavenPomCache mavenPomCache(ExecutionContext executionContext, ParserSettings parserSettings) { + InMemoryMavenPomCache mavenPomCache = new InMemoryMavenPomCache(); + MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); + return mavenPomCache; + } + + // if (pomCache == null) { +// if (isJvm64Bit()) { +// try { +// if (pomCacheDirectory == null) { +// //Default directory in the RocksdbMavenPomCache is ".rewrite-cache" +// pomCache = new CompositeMavenPomCache( +// new InMemoryMavenPomCache(), +// new RocksdbMavenPomCache(Paths.get(System.getProperty("user.home"))) +// ); +// } else { +// pomCache = new CompositeMavenPomCache( +// new InMemoryMavenPomCache(), +// new RocksdbMavenPomCache(Paths.get(pomCacheDirectory)) +// ); +// } +// } catch (Exception e) { +// logger.warn("Unable to initialize RocksdbMavenPomCache, falling back to InMemoryMavenPomCache"); +// logger.debug(e); +// } +// } else { +// logger.warn("RocksdbMavenPomCache is not supported on 32-bit JVM. falling back to InMemoryMavenPomCache"); +// } +// } +// if (pomCache == null) { +// MavenPomCache pomCache = new InMemoryMavenPomCache(); +// } +} diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java index cc0c88664..c00420970 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java @@ -27,6 +27,7 @@ import org.openrewrite.maven.AbstractRewriteMojo; import org.openrewrite.maven.MavenExecutionContextView; import org.openrewrite.maven.MavenMojoProjectParser; +import org.openrewrite.maven.cache.MavenPomCache; import org.openrewrite.maven.tree.MavenRepository; import org.openrewrite.style.NamedStyles; import org.openrewrite.tree.ParsingEventListener; @@ -91,7 +92,6 @@ public class RewriteProjectParser { private final ScanScope scanScope; private final ConfigurableListableBeanFactory beanFactory; - /** * Parse given {@link Resource}s in {@code baseDir} to OpenRewrite AST representation. *

From 53ef51c0726b24dd0cccadf483b306e56488e2a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Wed, 30 Aug 2023 11:05:11 +0200 Subject: [PATCH 2/8] WIP: blocked because scoepd beans don't exist --- sbm-support-rewrite/README.adoc | 37 +++++++++++ .../sbm/RewriteParserConfig.java | 40 ++++++++++++ .../sbm/parsers/BuildFileParser.java | 8 --- .../RewriteMavenPomCacheConfiguration.java | 65 ------------------- .../sbm/parsers/BuildFileParserTest.java | 3 +- 5 files changed, 79 insertions(+), 74 deletions(-) delete mode 100644 sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java diff --git a/sbm-support-rewrite/README.adoc b/sbm-support-rewrite/README.adoc index 664fff2ac..9b42e1f52 100644 --- a/sbm-support-rewrite/README.adoc +++ b/sbm-support-rewrite/README.adoc @@ -80,6 +80,43 @@ The `OpenRewriteProjectParser` aims to provide the exact same parsing capabiliti This allows parsing a given project to it's OpenRewrite AST representation and then provide the AST to OR recipes and visitors to run OpenRewrite recipes without requiring a build plugin. +## Configuration + +### Maven Pom Cache +OpenRewrite downloads Maven Pom files to resolve dependencies. +These pom files get cached and these cache implementations exist: + +- InMemoryMavenPomCache +- RocksdbMavenPomCache +- CompositeMavenPomCache + +#### Pom Cache Properties + +|=== +|Name |Description |Default Value + +|`parser.isPomCacheEnabled` +|If the flag is set to false, only the default, in-memory cache is used. +|`false` + +|`parser.pomCacheDirectory` +|Defines the cache dir for RocksdbMavenPomCache when `parser.isPomCacheEnabled` is `true` +|`~/.rewrite-cache` +|=== + +#### Custom Pom Cache +Users could provide a custom `MavenPomCache` implementation by overwriting the bean definition in `RewriteMavenPomCacheConfig.mavenPomCache()`. + +[source,java] +.... +@Bean +@Primary +public MavenPomCache mavenPomCache() { + return new CustomMavenPomCache(); +} +.... + + ## Running OpenRewrite recipes ### Scan the codebase diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java index dae6dc0f2..fbbdb0546 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java @@ -15,29 +15,69 @@ */ package org.springframework.sbm; +import lombok.extern.slf4j.Slf4j; +import org.openrewrite.ExecutionContext; import org.openrewrite.Recipe; import org.openrewrite.RecipeRun; import org.openrewrite.SourceFile; import org.openrewrite.internal.InMemoryLargeSourceSet; +import org.openrewrite.maven.MavenExecutionContextView; +import org.openrewrite.maven.cache.CompositeMavenPomCache; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; +import org.openrewrite.maven.cache.MavenPomCache; +import org.openrewrite.maven.cache.RocksdbMavenPomCache; import org.openrewrite.xml.tree.Xml; import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringBootConfiguration; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.context.ConfigurableApplicationContext; +import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.sbm.parsers.*; import org.springframework.sbm.recipes.RewriteRecipeDiscovery; +import java.io.PrintWriter; +import java.io.StringWriter; import java.nio.file.Path; import java.util.List; + /** * Module configuration. * * @author Fabian Krüger */ +@Slf4j @SpringBootApplication public class RewriteParserConfig { + @Bean + @ConditionalOnMissingBean(MavenPomCache.class) + MavenPomCache mavenPomCache(ExecutionContext executionContext, ParserSettings parserSettings) { + MavenPomCache mavenPomCache = new InMemoryMavenPomCache(); + if (parserSettings.isPomCacheEnabled()) { + if (!"32".equals(System.getProperty("sun.arch.data.model", "64"))) { + log.warn("parser.isPomCacheEnabled was set to true but RocksdbMavenPomCache is not supported on 32-bit JVM. falling back to InMemoryMavenPomCache"); + } else { + try { + mavenPomCache = new CompositeMavenPomCache( + new InMemoryMavenPomCache(), + new RocksdbMavenPomCache(Path.of(parserSettings.getPomCacheDirectory())) + ); + } catch (Exception e) { + log.warn("Unable to initialize RocksdbMavenPomCache, falling back to InMemoryMavenPomCache"); + if (log.isDebugEnabled()) { + StringWriter sw = new StringWriter(); + e.printStackTrace(new PrintWriter(sw)); + String exceptionAsString = sw.toString(); + log.debug(exceptionAsString); + } + } + } + } + MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); + return mavenPomCache; + } } diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java index e0475e286..4a9b0302b 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java @@ -51,7 +51,6 @@ @RequiredArgsConstructor class BuildFileParser { - private final ParserSettings parserSettings; private final MavenPomCache mavenPomCache; /** @@ -96,13 +95,6 @@ public Map parseBuildFiles( // 385 : 387 initializeMavenSettings(executionContext); - // 389 : 393 - if (parserSettings.isPomCacheEnabled()) { - //The default pom cache is enabled as a two-layer cache L1 == in-memory and L2 == RocksDb - //If the flag is set to false, only the default, in-memory cache is used. - MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); - } - // 395 : 398 mavenParserBuilder.activeProfiles(activeProfiles.toArray(new String[]{})); diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java deleted file mode 100644 index acf20d943..000000000 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteMavenPomCacheConfiguration.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright 2021 - 2022 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.sbm.parsers; - -import jdk.jfr.Enabled; -import org.openrewrite.ExecutionContext; -import org.openrewrite.maven.MavenExecutionContextView; -import org.openrewrite.maven.cache.InMemoryMavenPomCache; -import org.openrewrite.maven.cache.MavenPomCache; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; - -/** - * @author Fabian Krüger - */ -@Configuration -public class RewriteMavenPomCacheConfiguration { - @Bean - MavenPomCache mavenPomCache(ExecutionContext executionContext, ParserSettings parserSettings) { - InMemoryMavenPomCache mavenPomCache = new InMemoryMavenPomCache(); - MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); - return mavenPomCache; - } - - // if (pomCache == null) { -// if (isJvm64Bit()) { -// try { -// if (pomCacheDirectory == null) { -// //Default directory in the RocksdbMavenPomCache is ".rewrite-cache" -// pomCache = new CompositeMavenPomCache( -// new InMemoryMavenPomCache(), -// new RocksdbMavenPomCache(Paths.get(System.getProperty("user.home"))) -// ); -// } else { -// pomCache = new CompositeMavenPomCache( -// new InMemoryMavenPomCache(), -// new RocksdbMavenPomCache(Paths.get(pomCacheDirectory)) -// ); -// } -// } catch (Exception e) { -// logger.warn("Unable to initialize RocksdbMavenPomCache, falling back to InMemoryMavenPomCache"); -// logger.debug(e); -// } -// } else { -// logger.warn("RocksdbMavenPomCache is not supported on 32-bit JVM. falling back to InMemoryMavenPomCache"); -// } -// } -// if (pomCache == null) { -// MavenPomCache pomCache = new InMemoryMavenPomCache(); -// } -} diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java index e38d76aba..6c87de33d 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java @@ -25,6 +25,7 @@ import org.openrewrite.java.marker.JavaProject; import org.openrewrite.marker.Marker; import org.openrewrite.maven.MavenExecutionContextView; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; import org.openrewrite.maven.tree.*; import org.openrewrite.xml.tree.Xml; import org.springframework.core.io.Resource; @@ -104,7 +105,7 @@ public class GivenSimpleMavenMultiModuleProject { """; - private final BuildFileParser sut = new BuildFileParser(new ParserSettings()); + private final BuildFileParser sut = new BuildFileParser(new InMemoryMavenPomCache()); @Test void filterAndSortBuildFiles_shouldReturnSortedListOfFilteredBuildFiles() { From 45884d045bf2c18b6585ff3744ea8ebc9c1ea756 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:24:19 +0200 Subject: [PATCH 3/8] cleanup --- .../java/org/springframework/sbm/RewriteParserConfig.java | 5 +---- .../{ParserSettings.java => ParserProperties.java} | 8 +------- .../org/springframework/sbm/parsers/ProjectScanner.java | 1 - .../springframework/sbm/parsers/RewriteProjectParser.java | 1 - .../org/springframework/sbm/parsers/SourceFileParser.java | 1 - .../sbm/parsers/RewriteMavenProjectParserTest.java | 6 +++--- .../sbm/parsers/RewriteProjectParserTest.java | 7 ------- .../sbm/parsers/RewriteRecipeDiscoveryTest.java | 1 - 8 files changed, 5 insertions(+), 25 deletions(-) rename sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/{ParserSettings.java => ParserProperties.java} (90%) diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java index fbbdb0546..fc2577564 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java @@ -33,10 +33,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.Configuration; -import org.springframework.sbm.parsers.*; -import org.springframework.sbm.recipes.RewriteRecipeDiscovery; +import org.springframework.sbm.parsers.ParserProperties; import java.io.PrintWriter; import java.io.StringWriter; diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserSettings.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java similarity index 90% rename from sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserSettings.java rename to sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java index 2dbe075df..7de38654a 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserSettings.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java @@ -16,12 +16,9 @@ package org.springframework.sbm.parsers; import lombok.*; -import org.apache.commons.logging.Log; import org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.boot.context.properties.ConfigurationPropertiesBinding; import org.springframework.stereotype.Component; -import java.nio.file.Path; import java.util.HashSet; import java.util.List; import java.util.Set; @@ -40,10 +37,7 @@ public class ParserSettings { private String loggerClass; - /** - * Defines if pom files get cached or if they are always downloaded. - */ - private boolean pomCacheEnabled = true; + private boolean pomCacheEnabled = false; private String pomCacheDirectory; private boolean skipMavenParsing = false; private Set plainTextMasks = new HashSet<>(); diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java index 735a527de..2414a44b3 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java @@ -29,7 +29,6 @@ import java.nio.file.PathMatcher; import java.util.List; import java.util.Optional; -import java.util.Set; import java.util.stream.Stream; /** diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java index c00420970..869229dbe 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java @@ -27,7 +27,6 @@ import org.openrewrite.maven.AbstractRewriteMojo; import org.openrewrite.maven.MavenExecutionContextView; import org.openrewrite.maven.MavenMojoProjectParser; -import org.openrewrite.maven.cache.MavenPomCache; import org.openrewrite.maven.tree.MavenRepository; import org.openrewrite.style.NamedStyles; import org.openrewrite.tree.ParsingEventListener; diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java index 8c074b51c..0c5403087 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java @@ -33,7 +33,6 @@ import java.nio.file.Path; import java.nio.file.PathMatcher; import java.util.*; -import java.util.stream.Collectors; import java.util.stream.Stream; /** diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java index ccee605ba..baac0018b 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java @@ -357,9 +357,9 @@ private static void verifyExecutionContext(RewriteProjectParsingResult parsingRe assertThat( messages.get("org.openrewrite.parser.charset") ) - .isSameAs( - ParsingExecutionContextView.view(resultingExecutionContext).getCharset() - ); + .isSameAs( + ParsingExecutionContextView.view(resultingExecutionContext).getCharset() + ); assertThat(ParsingExecutionContextView.view(resultingExecutionContext).getCharset()).isEqualTo(Charset.defaultCharset()); // 4 diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java index c273097d0..a12d3ceaf 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java @@ -16,11 +16,9 @@ package org.springframework.sbm.parsers; import org.intellij.lang.annotations.Language; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import org.junitpioneer.jupiter.Issue; import org.openrewrite.ExecutionContext; import org.openrewrite.InMemoryExecutionContext; import org.openrewrite.Parser; @@ -35,13 +33,8 @@ import org.springframework.sbm.utils.ResourceUtil; import java.nio.file.Path; -import java.time.Instant; -import java.time.ZoneId; -import java.time.format.DateTimeFormatter; -import java.time.format.FormatStyle; import java.util.ArrayList; import java.util.List; -import java.util.Locale; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java index 193fb95dd..b7edbbab9 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java @@ -24,7 +24,6 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.condition.DisabledIfEnvironmentVariable; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; import org.openrewrite.Recipe; import org.openrewrite.config.*; import org.springframework.sbm.recipes.RewriteRecipeDiscovery; From f362c1fff3f11f4a705fcf9f3178953877114d65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:26:49 +0200 Subject: [PATCH 4/8] Log statement when MAven parsing is skipped --- .../java/org/springframework/sbm/parsers/BuildFileParser.java | 1 + 1 file changed, 1 insertion(+) diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java index 4a9b0302b..3e87626b3 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java @@ -81,6 +81,7 @@ public Map parseBuildFiles( Assert.isTrue(resourcesWithoutProvenanceMarker.isEmpty(), "No provenance marker provided for these pom files %s".formatted(resourcesWithoutProvenanceMarker.stream().map(r -> ResourceUtil.getPath(r).toAbsolutePath()).toList())); if(skipMavenParsing) { + log.info("Maven parsing skipped [parser.skipMavenParsing=true]."); return Map.of(); } From e33b87cca39904e6d2a7d0b3273e541400ffe898 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:27:05 +0200 Subject: [PATCH 5/8] Refactor Parser properties * Change properties file name * properties initialized with PostProcessor * Cache added to ExecutionContext on bean declaration * Remove unused property --- .../sbm/ParserPropertiesPostProcessor.java | 55 +++++++++++ .../sbm/RewriteParserConfig.java | 12 --- .../sbm/parsers/ParserProperties.java | 8 +- .../META-INF/sbm-support-rewrite.properties | 30 ++++++ .../main/resources/META-INF/spring.factories | 1 + .../src/main/resources/parser.properties | 0 .../sbm/parsers/ParserPropertiesTest.java | 94 +++++++++++++++++++ .../resources/parser-settings-test.properties | 11 --- 8 files changed, 181 insertions(+), 30 deletions(-) create mode 100644 sbm-support-rewrite/src/main/java/org/springframework/sbm/ParserPropertiesPostProcessor.java create mode 100644 sbm-support-rewrite/src/main/resources/META-INF/sbm-support-rewrite.properties create mode 100644 sbm-support-rewrite/src/main/resources/META-INF/spring.factories delete mode 100644 sbm-support-rewrite/src/main/resources/parser.properties create mode 100644 sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserPropertiesTest.java delete mode 100644 sbm-support-rewrite/src/test/resources/parser-settings-test.properties diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/ParserPropertiesPostProcessor.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/ParserPropertiesPostProcessor.java new file mode 100644 index 000000000..66ad92f09 --- /dev/null +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/ParserPropertiesPostProcessor.java @@ -0,0 +1,55 @@ +/* + * Copyright 2021 - 2023 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.sbm; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.env.EnvironmentPostProcessor; +import org.springframework.boot.env.PropertiesPropertySourceLoader; +import org.springframework.core.env.ConfigurableEnvironment; +import org.springframework.core.env.PropertySource; +import org.springframework.core.io.ClassPathResource; +import org.springframework.core.io.Resource; +import org.springframework.stereotype.Component; +import org.springframework.util.Assert; + +import java.io.IOException; + +/** + * Add default values from 'sbm-support-rewrite.properties' to environment. + */ +@Component +public class ParserPropertiesPostProcessor implements EnvironmentPostProcessor { + + private final PropertiesPropertySourceLoader loader = new PropertiesPropertySourceLoader(); + + @Override + public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { + Resource path = new ClassPathResource("/META-INF/sbm-support-rewrite.properties"); + PropertySource propertySource = loadProperties(path); + environment.getPropertySources().addLast(propertySource); + } + + private PropertySource loadProperties(Resource path) { + Assert.isTrue(path.exists(), () -> "Resource " + path + " does not exist"); + try { + return this.loader.load("custom-resource", path).get(0); + } + catch (IOException ex) { + throw new IllegalStateException("Failed to load properties configuration from " + path, ex); + } + } + +} \ No newline at end of file diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java index fc2577564..4f7e0bf09 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java @@ -16,29 +16,18 @@ package org.springframework.sbm; import lombok.extern.slf4j.Slf4j; -import org.openrewrite.ExecutionContext; -import org.openrewrite.Recipe; -import org.openrewrite.RecipeRun; -import org.openrewrite.SourceFile; -import org.openrewrite.internal.InMemoryLargeSourceSet; -import org.openrewrite.maven.MavenExecutionContextView; import org.openrewrite.maven.cache.CompositeMavenPomCache; import org.openrewrite.maven.cache.InMemoryMavenPomCache; import org.openrewrite.maven.cache.MavenPomCache; import org.openrewrite.maven.cache.RocksdbMavenPomCache; -import org.openrewrite.xml.tree.Xml; -import org.springframework.boot.SpringApplication; -import org.springframework.boot.SpringBootConfiguration; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; -import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.sbm.parsers.ParserProperties; import java.io.PrintWriter; import java.io.StringWriter; import java.nio.file.Path; -import java.util.List; /** @@ -74,7 +63,6 @@ MavenPomCache mavenPomCache(ExecutionContext executionContext, ParserSettings pa } } } - MavenExecutionContextView.view(executionContext).setPomCache(mavenPomCache); return mavenPomCache; } } diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java index 7de38654a..ede66c97c 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java @@ -25,6 +25,7 @@ /** * ConfigurationProperties with prefix {@code parser}. + * Defaults coming from {@code META-INF/sbm-support-rewrite.properties} * * @author Fabian Krüger */ @@ -47,13 +48,6 @@ public class ParserSettings { private List activeProfiles = List.of("default"); private Set ignoredPathPatterns = new HashSet<>(); - /** - * @return fully qualified classname of the logger to use. - */ - public String getLoggerClass() { - return loggerClass; - } - public void setLoggerClass(String loggerClass) { this.loggerClass = loggerClass; } diff --git a/sbm-support-rewrite/src/main/resources/META-INF/sbm-support-rewrite.properties b/sbm-support-rewrite/src/main/resources/META-INF/sbm-support-rewrite.properties new file mode 100644 index 000000000..58cd857b8 --- /dev/null +++ b/sbm-support-rewrite/src/main/resources/META-INF/sbm-support-rewrite.properties @@ -0,0 +1,30 @@ +# +# Copyright 2021 - 2023 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# Enable/Disable the MavenPomCache +# With 'false' OpenRewrite's InMemoryMavenPomCache will be used. +# With 'true' a composite cache of RocksdbMavenPomCache and InMemoryMavenPomCache will be used. +parser.pomCacheEnabled=false + +# Defines the cache dir for RocksdbMavenPomCache when `parser.pomCacheEnabled` is `true`. +parser.pomCacheDirectory=~/.rewrite-cache +parser.skipMavenParsing=false +parser.plainTextMasks=*.txt +parser.sizeThresholdMb=10 +parser.runPerSubmodule=true +parser.failOnInvalidActiveRecipes=true +parser.activeProfiles=default +parser.ignoredPathPatterns=**.idea,**.git diff --git a/sbm-support-rewrite/src/main/resources/META-INF/spring.factories b/sbm-support-rewrite/src/main/resources/META-INF/spring.factories new file mode 100644 index 000000000..d70d0a3f0 --- /dev/null +++ b/sbm-support-rewrite/src/main/resources/META-INF/spring.factories @@ -0,0 +1 @@ +org.springframework.boot.env.EnvironmentPostProcessor=org.springframework.sbm.ParserPropertiesPostProcessor \ No newline at end of file diff --git a/sbm-support-rewrite/src/main/resources/parser.properties b/sbm-support-rewrite/src/main/resources/parser.properties deleted file mode 100644 index e69de29bb..000000000 diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserPropertiesTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserPropertiesTest.java new file mode 100644 index 000000000..ad648f891 --- /dev/null +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserPropertiesTest.java @@ -0,0 +1,94 @@ +/* + * Copyright 2021 - 2023 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.sbm.parsers; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +import static org.assertj.core.api.Assertions.assertThat; + + + +class ParserPropertiesTest { + + @Nested + @SpringBootTest + public class GivenDefaultProperties { + + @Autowired + private ParserProperties parserProperties; + + @Test + @DisplayName("parser.pomCacheEnabled") + void validPomCacheEnabled() { + assertThat(parserProperties.isPomCacheEnabled()).isFalse(); + } + + + @Test + @DisplayName("parser.pomCacheDirectory") + void validPomCacheDirectory() { + assertThat(parserProperties.getPomCacheDirectory()).isEqualTo("~/.rewrite-cache"); + } + + @Test + @DisplayName("parser.skipMavenParsing") + void validSkipMavenParsing() { + assertThat(parserProperties.isSkipMavenParsing()).isFalse(); + } + + @Test + @DisplayName("parser.plainTextMasks") + void validPlainTextMasks() { + assertThat(parserProperties.getPlainTextMasks()).containsExactlyInAnyOrder("*.txt"); + } + + @Test + @DisplayName("parser.sizeThresholdMb") + void validSizeThresholdMb() { + assertThat(parserProperties.getSizeThresholdMb()).isEqualTo(10); + } + + @Test + @DisplayName("parser.runPerSubmodule") + void validRunPerSubmodule() { + assertThat(parserProperties.isRunPerSubmodule()).isTrue(); + } + + @Test + @DisplayName("parser.failOnInvalidActiveRecipes") + void validFailOnInvalidActiveRecipes() { + assertThat(parserProperties.isFailOnInvalidActiveRecipes()).isTrue(); + } + + @Test + @DisplayName("parser.activeProfiles") + void validActiveProfiles() { + assertThat(parserProperties.getActiveProfiles()).containsExactlyInAnyOrder("default"); + } + + @Test + @DisplayName("parser.ignoredPathPatterns") + void validIgnoredPathPatterns() { + assertThat(parserProperties.getIgnoredPathPatterns()).containsExactlyInAnyOrder("**.idea","**.git"); + } + + } + +} \ No newline at end of file diff --git a/sbm-support-rewrite/src/test/resources/parser-settings-test.properties b/sbm-support-rewrite/src/test/resources/parser-settings-test.properties deleted file mode 100644 index 03314fc66..000000000 --- a/sbm-support-rewrite/src/test/resources/parser-settings-test.properties +++ /dev/null @@ -1,11 +0,0 @@ -parser.loggerClass=com.acme.LoggerClass -parser.pomCacheEnabled=true -parser.pomCacheDirectory=some/dir -parser.skipMavenParsing=true -parser.exclusions=foo,bar/*,foo -parser.plainTextMasks=*.txt,*.md,*.txt -parser.sizeThresholdMb=10 -parser.runPerSubmodule=true -parser.failOnInvalidActiveRecipes=true -parser.activeProfiles=profile1,profile2 -parser.ignoredPathPatterns=/**/.idea/*,/**/.git/*,/**/.idea/* \ No newline at end of file From bf2997f8e30f341443b011ebf59e8d1c18a926a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:27:10 +0200 Subject: [PATCH 6/8] * Remove pomCache from parser --- sbm-support-rewrite/README.adoc | 9 +- .../sbm/parsers/BuildFileParser.java | 2 - .../sbm/scopes/ScopeConfiguration.java | 7 +- .../sbm/parsers/BuildFileParserTest.java | 2 +- .../sbm/parsers/MavenPomCacheTest.java | 136 ++++++++++++++++++ .../RewriteMavenProjectParserTest.java | 13 +- .../sbm/parsers/RewriteProjectParserTest.java | 4 +- 7 files changed, 155 insertions(+), 18 deletions(-) create mode 100644 sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/MavenPomCacheTest.java diff --git a/sbm-support-rewrite/README.adoc b/sbm-support-rewrite/README.adoc index 9b42e1f52..dcee471e4 100644 --- a/sbm-support-rewrite/README.adoc +++ b/sbm-support-rewrite/README.adoc @@ -84,11 +84,12 @@ This allows parsing a given project to it's OpenRewrite AST representation and t ### Maven Pom Cache OpenRewrite downloads Maven Pom files to resolve dependencies. -These pom files get cached and these cache implementations exist: +The pom files get cached and the cache depends on the system. -- InMemoryMavenPomCache -- RocksdbMavenPomCache -- CompositeMavenPomCache +- 32-Bit systems use the `InMemoryPomCache`. +- 64-Bit systems use the `RocksdbMavenPomCache`. + +#### #### Pom Cache Properties diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java index 3e87626b3..6d8cae015 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/BuildFileParser.java @@ -51,8 +51,6 @@ @RequiredArgsConstructor class BuildFileParser { - private final MavenPomCache mavenPomCache; - /** * Parse a list of Maven Pom files to a Map of {@code Path} and their parsed {@link Xml.Document}s. * The {@link Xml.Document}s are marked with {@link org.openrewrite.maven.tree.MavenResolutionResult} and the provided provenance markers. diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/scopes/ScopeConfiguration.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/scopes/ScopeConfiguration.java index 0cb422e3c..4e5ea0609 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/scopes/ScopeConfiguration.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/scopes/ScopeConfiguration.java @@ -18,6 +18,7 @@ import org.openrewrite.ExecutionContext; import org.openrewrite.InMemoryExecutionContext; import org.openrewrite.maven.MavenExecutionContextView; +import org.openrewrite.maven.cache.MavenPomCache; import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -52,9 +53,11 @@ Supplier executionContextSupplier() { @Bean @org.springframework.sbm.scopes.annotations.ExecutionScope - ExecutionContext executionContext(ProjectMetadata projectMetadata, Supplier executionContextSupplier) { + ExecutionContext executionContext(ProjectMetadata projectMetadata, Supplier executionContextSupplier, MavenPomCache mavenPomCache) { ExecutionContext executionContext = executionContextSupplier.get(); - MavenExecutionContextView.view(executionContext).setMavenSettings(projectMetadata.getMavenSettings()); + MavenExecutionContextView contextView = MavenExecutionContextView.view(executionContext); + contextView.setMavenSettings(projectMetadata.getMavenSettings()); + contextView.setPomCache(mavenPomCache); return executionContext; } diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java index 6c87de33d..4fe9254f4 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/BuildFileParserTest.java @@ -105,7 +105,7 @@ public class GivenSimpleMavenMultiModuleProject { """; - private final BuildFileParser sut = new BuildFileParser(new InMemoryMavenPomCache()); + private final BuildFileParser sut = new BuildFileParser(); @Test void filterAndSortBuildFiles_shouldReturnSortedListOfFilteredBuildFiles() { diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/MavenPomCacheTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/MavenPomCacheTest.java new file mode 100644 index 000000000..ba0a76cfa --- /dev/null +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/MavenPomCacheTest.java @@ -0,0 +1,136 @@ +/* + * Copyright 2021 - 2023 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.sbm.parsers; + +import org.junit.jupiter.api.*; +import org.junitpioneer.jupiter.SetSystemProperty; +import org.openrewrite.maven.cache.CompositeMavenPomCache; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; +import org.openrewrite.maven.cache.MavenPomCache; +import org.openrewrite.maven.cache.RocksdbMavenPomCache; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.context.TestConfiguration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Import; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * @author Fabian Krüger + */ +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +public class MavenPomCacheTest { + + private static final String originalArchDataModel = System.getProperty("sun.arch.data.model"); + + @Nested + @SetSystemProperty(key="sun.arch.data.model", value = "64") + class GivenA64BitSystem { + + @Nested + @SpringBootTest(properties = {"parser.pomCacheEnabled=true", "parser.pomCacheDirectory=target"}) + @DirtiesContext + class WhenPomCacheIsEnabledIsTrue { + + @Autowired + private MavenPomCache mavenPomCache; + + @Test + @DisplayName("When pomCacheEnabled is true a CompositeMavenPomCache gets be used") + void compositePomCacheShouldBeUsed() { + assertThat(mavenPomCache).isInstanceOf(CompositeMavenPomCache.class); + } + + @Test + @DisplayName("The used CompositeMavenPomCache should be Rocksdb and InMemory cache") + void compositePomCacheShouldBeUsed2() { + assertThat(mavenPomCache).isInstanceOf(CompositeMavenPomCache.class); + assertThat( + List.of( + ReflectionTestUtils.getField(mavenPomCache, "l1").getClass(), + ReflectionTestUtils.getField(mavenPomCache, "l2").getClass() + ) + ) + .containsExactly(InMemoryMavenPomCache.class, RocksdbMavenPomCache.class); + } + } + + @Nested + @SpringBootTest(properties = {"parser.pomCacheEnabled=false"}) + @DirtiesContext + class WhenPomCacheIsEnabledIsFalse { + + @Autowired + private MavenPomCache mavenPomCache; + + @Test + @DisplayName("When pomCacheEnabled is false a InMemoryMavenPomCache should be used") + void InMemoryMavenPomCacheShouldBeUsed() { + assertThat(mavenPomCache).isInstanceOf(InMemoryMavenPomCache.class); + } + } + + } + + @Nested + @DirtiesContext + @SpringBootTest(properties = {"parser.pomCacheEnabled=true"}) + @SetSystemProperty(key = "sun.arch.data.model", value = "32") + class GivenA32BitSystem { + + @Autowired + private MavenPomCache mavenPomCache; + + @Test + @DisplayName("With 32Bit an InMemory pom cache gets used") + void shouldUseInMemoryMavenPomCache() { + assertThat(mavenPomCache).isInstanceOf(InMemoryMavenPomCache.class); + } + } + + @Nested + @DirtiesContext + @Import(CustomCacheConfig.class) + @SpringBootTest(properties = {"parser.pomCacheEnabled=true"}) + class GivenCustomCacheProvided { + + @Autowired + private MavenPomCache mavenPomCache; + + @Test + @DisplayName("The custom pom cache should be used") + void shouldUseTheProvidedPomCache() { + assertThat(mavenPomCache).isInstanceOf(CustomPomCache.class); + } + } +} + +@TestConfiguration +class CustomCacheConfig { + // Provide custom MavenPomCache as bean + // Should overwrite the existing MavenPomCache + @Bean + public MavenPomCache mavenPomCache() { + return new CustomPomCache(); + } +} + +class CustomPomCache extends InMemoryMavenPomCache {} diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java index baac0018b..ed5e7a429 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java @@ -38,7 +38,7 @@ import org.openrewrite.marker.ci.GithubActionsBuildEnvironment; import org.openrewrite.maven.MavenExecutionContextView; import org.openrewrite.maven.MavenSettings; -import org.openrewrite.maven.cache.CompositeMavenPomCache; +import org.openrewrite.maven.cache.InMemoryMavenPomCache; import org.openrewrite.maven.tree.MavenResolutionResult; import org.openrewrite.shaded.jgit.api.Git; import org.openrewrite.shaded.jgit.api.errors.GitAPIException; @@ -272,8 +272,8 @@ void parseMultiModule1_WithCustomParser() { RewriteProjectParser rpp = new RewriteProjectParser( new MavenExecutor(new MavenExecutionRequestFactory(new MavenConfigFileParser()), new MavenPlexusContainer()), new ProvenanceMarkerFactory(mavenMojoProjectParserFactory), - new BuildFileParser(parserSettings), - new SourceFileParser(mavenModelReader, parserSettings, mavenMojoParserPrivateMethods), + new BuildFileParser(), + new SourceFileParser(mavenModelReader, parserProperties, mavenMojoParserPrivateMethods), new StyleDetector(), parserSettings, mock(ParsingEventListener.class), @@ -399,10 +399,9 @@ private static void verifyExecutionContext(RewriteProjectParsingResult parsingRe // 8 assertThat( messages.get("org.openrewrite.maven.pomCache") - ).isSameAs( - MavenExecutionContextView.view(resultingExecutionContext).getPomCache() - ); - assertThat(MavenExecutionContextView.view(resultingExecutionContext).getPomCache()).isInstanceOf(CompositeMavenPomCache.class); + ).isNull(); + assertThat(MavenExecutionContextView.view(resultingExecutionContext).getPomCache()).isInstanceOf(InMemoryMavenPomCache.class); +// assertThat(MavenExecutionContextView.view(resultingExecutionContext).getPomCache()).isInstanceOf(CompositeMavenPomCache.class); // 9 // FIXME: This fails sometimes when multiple tests are run together. The resolution time has been 0 and null diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java index a12d3ceaf..5a3c939b9 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java @@ -93,8 +93,8 @@ void parseSimpleMavenProject(@TempDir Path tempDir) { RewriteProjectParser projectParser = new RewriteProjectParser( new MavenExecutor(new MavenExecutionRequestFactory(new MavenConfigFileParser()), new MavenPlexusContainer()), new ProvenanceMarkerFactory(mavenMojoProjectParserFactory), - new BuildFileParser(parserSettings), - new SourceFileParser(mavenModelReader, parserSettings, mavenMojoParserPrivateMethods), + new BuildFileParser(), + new SourceFileParser(mavenModelReader, parserProperties, mavenMojoParserPrivateMethods), new StyleDetector(), parserSettings, mock(ParsingEventListener.class), From 3fdba6f08d90fa357bbca6f92f2656b0fbc155f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:27:29 +0200 Subject: [PATCH 7/8] Rename ParserSettings to ParserProperties --- .../sbm/RewriteParserConfig.java | 8 +- .../MavenMojoProjectParserFactory.java | 30 ++--- .../sbm/parsers/ParserProperties.java | 3 +- .../sbm/parsers/ProjectScanner.java | 4 +- .../sbm/parsers/RewriteProjectParser.java | 4 +- .../sbm/parsers/SourceFileParser.java | 10 +- .../sbm/recipes/RewriteRecipeDiscovery.java | 8 +- ...ParserEventPublicationIntegrationTest.java | 4 +- .../sbm/parsers/ParserSettingsTest.java | 108 ------------------ .../parsers/ProvenanceMarkerFactoryTest.java | 2 +- .../RewriteMavenProjectParserTest.java | 18 +-- .../sbm/parsers/RewriteProjectParserTest.java | 6 +- .../parsers/RewriteRecipeDiscoveryTest.java | 2 +- 13 files changed, 50 insertions(+), 157 deletions(-) delete mode 100644 sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserSettingsTest.java diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java index 4f7e0bf09..9d129cbfd 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/RewriteParserConfig.java @@ -41,16 +41,16 @@ public class RewriteParserConfig { @Bean @ConditionalOnMissingBean(MavenPomCache.class) - MavenPomCache mavenPomCache(ExecutionContext executionContext, ParserSettings parserSettings) { + MavenPomCache mavenPomCache(ParserProperties parserProperties) { MavenPomCache mavenPomCache = new InMemoryMavenPomCache(); - if (parserSettings.isPomCacheEnabled()) { - if (!"32".equals(System.getProperty("sun.arch.data.model", "64"))) { + if (parserProperties.isPomCacheEnabled()) { + if (!"64".equals(System.getProperty("sun.arch.data.model", "64"))) { log.warn("parser.isPomCacheEnabled was set to true but RocksdbMavenPomCache is not supported on 32-bit JVM. falling back to InMemoryMavenPomCache"); } else { try { mavenPomCache = new CompositeMavenPomCache( new InMemoryMavenPomCache(), - new RocksdbMavenPomCache(Path.of(parserSettings.getPomCacheDirectory())) + new RocksdbMavenPomCache(Path.of(parserProperties.getPomCacheDirectory())) ); } catch (Exception e) { log.warn("Unable to initialize RocksdbMavenPomCache, falling back to InMemoryMavenPomCache"); diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/MavenMojoProjectParserFactory.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/MavenMojoProjectParserFactory.java index 15f288efd..2480971ed 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/MavenMojoProjectParserFactory.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/MavenMojoProjectParserFactory.java @@ -39,19 +39,19 @@ @RequiredArgsConstructor class MavenMojoProjectParserFactory { - private final ParserSettings parserSettings; + private final ParserProperties parserProperties; public MavenMojoProjectParser create(Path baseDir, List mavenProjects, PlexusContainer plexusContainer, MavenSession session) { return buildMavenMojoProjectParser( baseDir, mavenProjects, - parserSettings.isPomCacheEnabled(), - parserSettings.getPomCacheDirectory(), - parserSettings.isSkipMavenParsing(), - parserSettings.getIgnoredPathPatterns(), - parserSettings.getPlainTextMasks(), - parserSettings.getSizeThresholdMb(), - parserSettings.isRunPerSubmodule(), + parserProperties.isPomCacheEnabled(), + parserProperties.getPomCacheDirectory(), + parserProperties.isSkipMavenParsing(), + parserProperties.getIgnoredPathPatterns(), + parserProperties.getPlainTextMasks(), + parserProperties.getSizeThresholdMb(), + parserProperties.isRunPerSubmodule(), plexusContainer, session); } @@ -98,16 +98,16 @@ public MavenMojoProjectParser create(Path baseDir, RuntimeInformation runtimeInf return new MavenMojoProjectParser( new Slf4jToMavenLoggerAdapter(log), baseDir, - parserSettings.isPomCacheEnabled(), - parserSettings.getPomCacheDirectory(), + parserProperties.isPomCacheEnabled(), + parserProperties.getPomCacheDirectory(), runtimeInformation, - parserSettings.isSkipMavenParsing(), - parserSettings.getIgnoredPathPatterns(), - parserSettings.getPlainTextMasks(), - parserSettings.getSizeThresholdMb(), + parserProperties.isSkipMavenParsing(), + parserProperties.getIgnoredPathPatterns(), + parserProperties.getPlainTextMasks(), + parserProperties.getSizeThresholdMb(), null, settingsDecrypter, - parserSettings.isRunPerSubmodule() + parserProperties.isRunPerSubmodule() ); } } diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java index ede66c97c..29569aaec 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ParserProperties.java @@ -35,7 +35,8 @@ @AllArgsConstructor @NoArgsConstructor @ConfigurationProperties(prefix = "parser") -public class ParserSettings { +@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") +public class ParserProperties { private String loggerClass; private boolean pomCacheEnabled = false; diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java index 2414a44b3..195051289 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/ProjectScanner.java @@ -39,7 +39,7 @@ @RequiredArgsConstructor class ProjectScanner { private final ResourceLoader resourceLoader; - private final ParserSettings parserSettings; + private final ParserProperties parserProperties; public List scan(Path baseDir) { if(!baseDir.isAbsolute()) { @@ -54,7 +54,7 @@ public List scan(Path baseDir) { try { Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources(pattern); - List pathMatchers = parserSettings.getIgnoredPathPatterns().stream() + List pathMatchers = parserProperties.getIgnoredPathPatterns().stream() .map(p -> p.startsWith("glob:") ? p : "glob:" + p) .map(baseDir.getFileSystem()::getPathMatcher) .toList(); diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java index 869229dbe..0e1bde935 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/RewriteProjectParser.java @@ -85,7 +85,7 @@ public class RewriteProjectParser { private final BuildFileParser buildFileParser; private final SourceFileParser sourceFileParser; private final StyleDetector styleDetector; - private final ParserSettings parserSettings; + private final ParserProperties parserProperties; private final ParsingEventListener parsingEventListener; private final ApplicationEventPublisher eventPublisher; private final ScanScope scanScope; @@ -146,7 +146,7 @@ public RewriteProjectParsingResult parse(Path givenBaseDir, List resou Map> provenanceMarkers = provenanceMarkerFactory.generateProvenanceMarkers(baseDir, mavenInfos); // 127: parse build files - Map resourceToDocumentMap = buildFileParser.parseBuildFiles(baseDir, mavenInfos.getResources(), mavenInfos.getActiveProfiles(), executionContext, parserSettings.isSkipMavenParsing(), provenanceMarkers); + Map resourceToDocumentMap = buildFileParser.parseBuildFiles(baseDir, mavenInfos.getResources(), mavenInfos.getActiveProfiles(), executionContext, parserProperties.isSkipMavenParsing(), provenanceMarkers); List parsedAndSortedBuildFileDocuments = mavenInfos.getResources().stream() .map(r -> resourceToDocumentMap.get(ResourceUtil.getPath(r))) diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java index 0c5403087..460145f20 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/parsers/SourceFileParser.java @@ -44,7 +44,7 @@ class SourceFileParser { private final MavenModelReader modelReader; - private final ParserSettings parserSettings; + private final ParserProperties parserProperties; private final MavenMojoProjectParserPrivateMethods mavenMojoProjectParserPrivateMethods; public List parseOtherSourceFiles( @@ -101,9 +101,9 @@ private List parseModuleSourceFiles( ResourceParser rp = new ResourceParser( baseDir, new Slf4jToMavenLoggerAdapter(log), - parserSettings.getIgnoredPathPatterns(), - parserSettings.getPlainTextMasks(), - parserSettings.getSizeThresholdMb(), + parserProperties.getIgnoredPathPatterns(), + parserProperties.getPlainTextMasks(), + parserProperties.getSizeThresholdMb(), pathsToOtherModules, javaParserBuilder.clone() ); @@ -120,7 +120,7 @@ private List parseModuleSourceFiles( .map(mavenMojoProjectParserPrivateMethods.addProvenance(baseDir, provenanceMarkers, null)); // 157:169 - List resourceSourceFiles = mergeAndFilterExcluded(baseDir, parserSettings.getIgnoredPathPatterns(), mainSources, testSources); + List resourceSourceFiles = mergeAndFilterExcluded(baseDir, parserProperties.getIgnoredPathPatterns(), mainSources, testSources); List resourceFilesList = parsedResourceFiles.toList(); sourceFiles.addAll(resourceFilesList); sourceFiles.addAll(resourceSourceFiles); diff --git a/sbm-support-rewrite/src/main/java/org/springframework/sbm/recipes/RewriteRecipeDiscovery.java b/sbm-support-rewrite/src/main/java/org/springframework/sbm/recipes/RewriteRecipeDiscovery.java index e6e1534cf..814564529 100644 --- a/sbm-support-rewrite/src/main/java/org/springframework/sbm/recipes/RewriteRecipeDiscovery.java +++ b/sbm-support-rewrite/src/main/java/org/springframework/sbm/recipes/RewriteRecipeDiscovery.java @@ -29,7 +29,7 @@ import org.openrewrite.internal.lang.Nullable; import org.openrewrite.maven.AbstractRewriteMojo; import org.springframework.sbm.parsers.RecipeValidationErrorException; -import org.springframework.sbm.parsers.ParserSettings; +import org.springframework.sbm.parsers.ParserProperties; import org.springframework.stereotype.Component; import java.nio.file.Path; @@ -51,7 +51,7 @@ @RequiredArgsConstructor public class RewriteRecipeDiscovery { - private final ParserSettings parserSettings; + private final ParserProperties parserProperties; /** * */ @@ -89,7 +89,7 @@ public List discoverFilteredRecipes(List activeRecipes, Properti failedValidations.forEach(failedValidation -> log.error( "Recipe validation error in " + failedValidation.getProperty() + ": " + failedValidation.getMessage(), failedValidation.getException())); - if (parserSettings.isFailOnInvalidActiveRecipes()) { + if (parserProperties.isFailOnInvalidActiveRecipes()) { throw new RecipeValidationErrorException("Recipe validation errors detected as part of one or more activeRecipe(s). Please check error logs."); } else { log.error("Recipe validation errors detected as part of one or more activeRecipe(s). Execution will continue regardless."); @@ -127,7 +127,7 @@ public List discoverFilteredRecipes(List activeRecipes, MavenPro failedValidations.forEach(failedValidation -> log.error( "Recipe validation error in " + failedValidation.getProperty() + ": " + failedValidation.getMessage(), failedValidation.getException())); - if (parserSettings.isFailOnInvalidActiveRecipes()) { + if (parserProperties.isFailOnInvalidActiveRecipes()) { throw new RecipeValidationErrorException("Recipe validation errors detected as part of one or more activeRecipe(s). Please check error logs."); } else { log.error("Recipe validation errors detected as part of one or more activeRecipe(s). Execution will continue regardless."); diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserEventPublicationIntegrationTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserEventPublicationIntegrationTest.java index e59d76d57..0da3c2579 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserEventPublicationIntegrationTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserEventPublicationIntegrationTest.java @@ -48,7 +48,7 @@ public class ParserEventPublicationIntegrationTest { ProjectScanner projectScanner; @Autowired - ParserSettings parserSettings; + ParserProperties parserProperties; private static List capturedEvents = new ArrayList<>(); private static StartedParsingProjectEvent startedParsingEvent; @@ -58,7 +58,7 @@ public class ParserEventPublicationIntegrationTest { @DisplayName("Should publish parsing events") void shouldPublishParsingEvents() { Path baseDir = Path.of("./testcode/maven-projects/multi-module-events"); - parserSettings.setIgnoredPathPatterns(Set.of("{**/target,target}", "**.adoc")); + parserProperties.setIgnoredPathPatterns(Set.of("{**/target,target}", "**.adoc")); List resources = projectScanner.scan(baseDir); ExecutionContext ctx = new InMemoryExecutionContext(t -> {throw new RuntimeException(t);}); diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserSettingsTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserSettingsTest.java deleted file mode 100644 index 28a825ba3..000000000 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ParserSettingsTest.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright 2021 - 2023 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.sbm.parsers; - -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Nested; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.context.properties.EnableConfigurationProperties; -import org.springframework.test.context.TestPropertySource; -import org.springframework.test.context.junit.jupiter.SpringExtension; - -import java.nio.file.Path; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -/** - * @author Fabian Krüger - */ -@ExtendWith(SpringExtension.class) -@EnableConfigurationProperties(value = ParserSettings.class) -@TestPropertySource("classpath:parser-settings-test.properties") -class ParserSettingsTest { - - @Nested - public class ValidProperties { - - @Autowired - ParserSettings parserSettings; - - @Test - @DisplayName("valid LoggerClass") - void validLoggerClass() { - assertThat(parserSettings.getLoggerClass()).isEqualTo("com.acme.LoggerClass"); - } - - @Test - @DisplayName("valid Pom Cache enabled") - void validPomCacheEnabled() { - assertThat(parserSettings.isPomCacheEnabled()).isTrue(); - } - - @Test - @DisplayName("valid pomCacheDirectory") - void validPomCacheDirectory() { - assertThat(parserSettings.getPomCacheDirectory()).isEqualTo("some/dir"); - } - - @Test - @DisplayName("valid skipMavenParsing") - void validSkipMavenParsing() { - assertThat(parserSettings.isSkipMavenParsing()).isTrue(); - } - - @Test - @DisplayName("valid plainTextMasks") - void validPlainTextMasks() { - assertThat(parserSettings.getPlainTextMasks()).containsExactlyInAnyOrder("*.txt", "*.md"); - } - - @Test - @DisplayName("valid sizeThresholdMb") - void validSizeThresholdMb() { - assertThat(parserSettings.getSizeThresholdMb()).isEqualTo(10); - } - - @Test - @DisplayName("valid runPerSubmodule") - void validRunPerSubmodule() { - assertThat(parserSettings.isRunPerSubmodule()).isTrue(); - } - - @Test - @DisplayName("valid failOnInvalidActiveRecipes") - void validFailOnInvalidActiveRecipes() { - assertThat(parserSettings.isFailOnInvalidActiveRecipes()).isTrue(); - } - - @Test - @DisplayName("valid activeProfiles") - void validActiveProfiles() { - assertThat(parserSettings.getActiveProfiles()).containsExactlyInAnyOrder("profile1", "profile2"); - } - - @Test - @DisplayName("valid ignoredPathPatterns") - void validIgnoredPathPatterns() { - assertThat(parserSettings.getIgnoredPathPatterns()).containsExactlyInAnyOrder("/**/.idea/*", "/**/.git/*"); - } - } - -} \ No newline at end of file diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ProvenanceMarkerFactoryTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ProvenanceMarkerFactoryTest.java index df4d6673d..9cb30a29c 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ProvenanceMarkerFactoryTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/ProvenanceMarkerFactoryTest.java @@ -71,7 +71,7 @@ void testMavenMojoProjectParserGenerateProvenance() { // create sut using a factory RuntimeInformation runtimeInformation = new DefaultRuntimeInformation(); SettingsDecrypter settingsDecrypter = null; - MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(new ParserSettings()); + MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(new ParserProperties()); MavenMojoProjectParser sut = mavenMojoProjectParserFactory.create(baseDir, runtimeInformation, settingsDecrypter); // the sut requires a MavenProject, let's retrieve it from Maven diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java index ed5e7a429..04dff6b96 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteMavenProjectParserTest.java @@ -82,7 +82,7 @@ class RewriteMavenProjectParserTest { new MavenConfigFileParser() ); MavenPlexusContainer plexusContainer = new MavenPlexusContainer(); - private ParserSettings parserSettings = new ParserSettings(); + private ParserProperties parserProperties = new ParserProperties(); private RewriteMavenProjectParser sut; private ConfigurableListableBeanFactory beanFactory; private ScanScope scanScope; @@ -95,7 +95,7 @@ void beforeEach() { plexusContainer, new RewriteParsingEventListenerAdapter(mock(ApplicationEventPublisher.class)), new MavenExecutor(requestFactory, plexusContainer), - new MavenMojoProjectParserFactory(parserSettings), + new MavenMojoProjectParserFactory(parserProperties), scanScope, beanFactory, new InMemoryExecutionContext(t -> {throw new RuntimeException(t);}) @@ -164,7 +164,7 @@ public static void main(String[] args){ ); ResourceUtil.write(tempDir, resources); - parserSettings.setIgnoredPathPatterns(Set.of("**/testcode/**", "testcode/**", ".rewrite-cache/**")); + parserProperties.setIgnoredPathPatterns(Set.of("**/testcode/**", "testcode/**", ".rewrite-cache/**")); // call SUT RewriteProjectParsingResult parsingResult = sut.parse( tempDir, @@ -240,7 +240,7 @@ public static void main(String[] args){ @Disabled("https://github.com/openrewrite/rewrite/issues/3409") void shouldParseMavenConfigProject() { Path baseDir = Path.of("./testcode/maven-projects/maven-config").toAbsolutePath().normalize(); - parserSettings.setIgnoredPathPatterns(Set.of(".mvn")); + parserProperties.setIgnoredPathPatterns(Set.of(".mvn")); RewriteProjectParsingResult parsingResult = sut.parse( baseDir, new InMemoryExecutionContext(t -> fail(t.getMessage())) @@ -253,7 +253,7 @@ void shouldParseMavenConfigProject() { void parseMultiModule1_withIntegratedParser() { ExecutionContext ctx = new InMemoryExecutionContext(t -> t.printStackTrace()); Path baseDir = getMavenProject("multi-module-1"); - parserSettings.setIgnoredPathPatterns(Set.of("README.adoc")); + parserProperties.setIgnoredPathPatterns(Set.of("README.adoc")); RewriteProjectParsingResult parsingResult = sut.parse( baseDir, ctx); @@ -266,7 +266,7 @@ void parseMultiModule1_WithCustomParser() { ExecutionContext ctx; ctx = new InMemoryExecutionContext(t -> t.printStackTrace()); MavenModelReader mavenModelReader = new MavenModelReader(); - MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(parserSettings); + MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(parserProperties); MavenMojoProjectParserPrivateMethods mavenMojoParserPrivateMethods = new MavenMojoProjectParserPrivateMethods(mavenMojoProjectParserFactory, new RewriteMavenArtifactDownloader()); RewriteProjectParser rpp = new RewriteProjectParser( @@ -275,7 +275,7 @@ void parseMultiModule1_WithCustomParser() { new BuildFileParser(), new SourceFileParser(mavenModelReader, parserProperties, mavenMojoParserPrivateMethods), new StyleDetector(), - parserSettings, + parserProperties, mock(ParsingEventListener.class), mock(ApplicationEventPublisher.class), scanScope, @@ -283,7 +283,7 @@ void parseMultiModule1_WithCustomParser() { ); Set ignoredPatters = Set.of(); - ProjectScanner projectScanner = new ProjectScanner(new FileSystemResourceLoader(), parserSettings); + ProjectScanner projectScanner = new ProjectScanner(new FileSystemResourceLoader(), parserProperties); List resources = projectScanner.scan(baseDir); RewriteProjectParsingResult parsingResult1 = rpp.parse(baseDir, resources, ctx); @@ -309,7 +309,7 @@ void parseComplexMavenReactorProject() { System.out.println("%s: Parsed file: %s".formatted(format, sourceFile.getSourcePath())); parsedFiles.add(sourceFile.getSourcePath().toString()); }); - parserSettings.setIgnoredPathPatterns(Set.of("**/testcode/**", ".rewrite/**", "internal/**")); + parserProperties.setIgnoredPathPatterns(Set.of("**/testcode/**", ".rewrite/**", "internal/**")); RewriteProjectParsingResult parsingResult = projectParser.parse( projectRoot, executionContext diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java index 5a3c939b9..1299feff5 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteProjectParserTest.java @@ -86,9 +86,9 @@ public static void main(String[] args){ @DisplayName("Parse simple Maven project") void parseSimpleMavenProject(@TempDir Path tempDir) { Path basePath = tempDir; - ParserSettings parserSettings = new ParserSettings(); + ParserProperties parserProperties = new ParserProperties(); MavenModelReader mavenModelReader = new MavenModelReader(); - MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(parserSettings); + MavenMojoProjectParserFactory mavenMojoProjectParserFactory = new MavenMojoProjectParserFactory(parserProperties); MavenMojoProjectParserPrivateMethods mavenMojoParserPrivateMethods = new MavenMojoProjectParserPrivateMethods(mavenMojoProjectParserFactory, new RewriteMavenArtifactDownloader()); RewriteProjectParser projectParser = new RewriteProjectParser( new MavenExecutor(new MavenExecutionRequestFactory(new MavenConfigFileParser()), new MavenPlexusContainer()), @@ -96,7 +96,7 @@ void parseSimpleMavenProject(@TempDir Path tempDir) { new BuildFileParser(), new SourceFileParser(mavenModelReader, parserProperties, mavenMojoParserPrivateMethods), new StyleDetector(), - parserSettings, + parserProperties, mock(ParsingEventListener.class), mock(ApplicationEventPublisher.class), new ScanScope(), diff --git a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java index b7edbbab9..7662eeeed 100644 --- a/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java +++ b/sbm-support-rewrite/src/test/java/org/springframework/sbm/parsers/RewriteRecipeDiscoveryTest.java @@ -270,6 +270,6 @@ private static Optional getRecipeByDisplayName(List recipes, Str @NotNull private static RewriteRecipeDiscovery buildRecipeDiscovery() { - return new RewriteRecipeDiscovery(new ParserSettings()); + return new RewriteRecipeDiscovery(new ParserProperties()); } } \ No newline at end of file From e47a88b01813ca54cf33beac0237aeb0578f9183 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fabian=20Kr=C3=BCger?= Date: Mon, 4 Sep 2023 16:47:19 +0200 Subject: [PATCH 8/8] build action --- .github/workflows/build-sbm-support-rewrite.yml | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/.github/workflows/build-sbm-support-rewrite.yml b/.github/workflows/build-sbm-support-rewrite.yml index e18036705..28c1ac754 100644 --- a/.github/workflows/build-sbm-support-rewrite.yml +++ b/.github/workflows/build-sbm-support-rewrite.yml @@ -2,10 +2,7 @@ name: Build SBM Revamp on: push: branches: - - "revamp/**" - - "version/revamp" - branches-ignore: - - "main" + - "**" paths: - "sbm-support-rewrite/**" jobs: