From e3ec1aab09c72090c4024e6f3109142f1489f52e Mon Sep 17 00:00:00 2001 From: Vladimir Krivosheev Date: Thu, 12 Sep 2024 13:24:54 +0200 Subject: [PATCH] simplify - CommonPathRelativizer.basePath is not-null GitOrigin-RevId: 3af6fa8ecbec64408bfa6ea5508d1dcd11b4e58a --- .../relativizer/CommonPathRelativizer.kt | 27 ++------- .../relativizer/GradlePathRelativizer.java | 18 +++--- .../relativizer/JavaSdkPathRelativizer.java | 24 +++----- .../relativizer/MavenPathRelativizer.java | 17 +++--- .../relativizer/PathRelativizerService.java | 59 +++++++++++-------- 5 files changed, 65 insertions(+), 80 deletions(-) diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/CommonPathRelativizer.kt b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/CommonPathRelativizer.kt index baba7129e631..551151bace4d 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/CommonPathRelativizer.kt +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/CommonPathRelativizer.kt @@ -5,30 +5,15 @@ import com.intellij.openapi.util.SystemInfoRt import com.intellij.openapi.util.io.FileUtil internal open class CommonPathRelativizer @JvmOverloads constructor( - private val basePath: String?, private val identifier: String, - /** - * can be null when basePath is null, or it is impossible to detect the sensitivity of the file system - */ - private val isCaseSensitive: Boolean? = null + private val basePath: String, + private val identifier: String, + private val isCaseSensitive: Boolean = SystemInfoRt.isFileSystemCaseSensitive, ) : PathRelativizer { override fun toRelativePath(path: String): String? { - if (basePath == null || - !(if (isCaseSensitive == null) - FileUtil.startsWith(path, basePath, SystemInfoRt.isFileSystemCaseSensitive) - else - FileUtil.startsWith(path, basePath, isCaseSensitive)) - ) { - return null - } - return identifier + path.substring(basePath.length) + return if (FileUtil.startsWith(path, basePath, isCaseSensitive)) identifier + path.substring(basePath.length) else null } override fun toAbsolutePath(path: String): String? { - if (basePath == null || !path.startsWith(identifier)) { - return null - } - else { - return basePath + path.substring(identifier.length) - } + return if (path.startsWith(identifier)) basePath + path.substring(identifier.length) else null } -} +} \ No newline at end of file diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/GradlePathRelativizer.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/GradlePathRelativizer.java index 3bc9bf6bcbfd..ef889ed63c0e 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/GradlePathRelativizer.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/GradlePathRelativizer.java @@ -1,27 +1,25 @@ -// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package org.jetbrains.jps.incremental.relativizer; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.SystemProperties; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; final class GradlePathRelativizer extends CommonPathRelativizer { private static final String IDENTIFIER = "$GRADLE_REPOSITORY$"; private static final String GRADLE_USER_HOME = "GRADLE_USER_HOME"; - GradlePathRelativizer() { - super(initializeGradleRepositoryPath(), IDENTIFIER); + GradlePathRelativizer(@NotNull String gradleRepositoryPath) { + super(gradleRepositoryPath, IDENTIFIER); } - private static @Nullable String initializeGradleRepositoryPath() { + static @Nullable String initializeGradleRepositoryPath() { String gradleUserHomePath = System.getenv(GRADLE_USER_HOME); String gradleUserHome = gradleUserHomePath == null ? SystemProperties.getUserHome() + File.separator + ".gradle" : gradleUserHomePath; - - if (FileUtil.exists(gradleUserHome)) { - return PathRelativizerService.normalizePath(gradleUserHome); - } - return null; + return Files.exists(Path.of(gradleUserHome)) ? PathRelativizerService.normalizePath(gradleUserHome) : null; } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/JavaSdkPathRelativizer.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/JavaSdkPathRelativizer.java index 76ee38fe3720..104ec32868ae 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/JavaSdkPathRelativizer.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/JavaSdkPathRelativizer.java @@ -18,24 +18,18 @@ import java.util.stream.Collectors; * {@link PathRelativizerService#toRelative} or {@link PathRelativizerService#toFull} with any path. */ final class JavaSdkPathRelativizer implements PathRelativizer { - private @Nullable Map javaSdkPathMap; + private final @NotNull Map javaSdkPathMap; - JavaSdkPathRelativizer(@Nullable Set> javaSdks) { - if (javaSdks != null) { - javaSdkPathMap = javaSdks.stream() - .collect(Collectors.toMap(sdk -> { - JavaVersion version = JavaVersion.tryParse(sdk.getVersionString()); - return "$JDK_" + (version != null ? version.toString() : "0") + "$"; - }, sdk -> PathRelativizerService.normalizePath(sdk.getHomePath()), (sdk1, sdk2) -> sdk1)); - } + JavaSdkPathRelativizer(@NotNull Set> javaSdks) { + javaSdkPathMap = javaSdks.stream() + .collect(Collectors.toMap(sdk -> { + JavaVersion version = JavaVersion.tryParse(sdk.getVersionString()); + return "$JDK_" + (version == null ? "0" : version.toString()) + "$"; + }, sdk -> PathRelativizerService.normalizePath(sdk.getHomePath()), (sdk1, sdk2) -> sdk1)); } @Override public @Nullable String toRelativePath(@NotNull String path) { - if (javaSdkPathMap == null || javaSdkPathMap.isEmpty()) { - return null; - } - for (Map.Entry entry : javaSdkPathMap.entrySet()) { if (FileUtil.startsWith(path, entry.getValue())) { return entry.getKey() + path.substring(entry.getValue().length()); @@ -46,10 +40,6 @@ final class JavaSdkPathRelativizer implements PathRelativizer { @Override public @Nullable String toAbsolutePath(@NotNull String path) { - if (javaSdkPathMap == null || javaSdkPathMap.isEmpty()) { - return null; - } - for (Map.Entry it : javaSdkPathMap.entrySet()) { if (path.startsWith(it.getKey())) { return it.getValue() + path.substring(it.getKey().length()); diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/MavenPathRelativizer.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/MavenPathRelativizer.java index 2537c09601aa..a8030e687e1f 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/MavenPathRelativizer.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/MavenPathRelativizer.java @@ -1,22 +1,23 @@ -// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package org.jetbrains.jps.incremental.relativizer; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.VisibleForTesting; import org.jetbrains.jps.model.serialization.JpsMavenSettings; @VisibleForTesting +@ApiStatus.Internal public final class MavenPathRelativizer extends CommonPathRelativizer { private static final String IDENTIFIER = "$MAVEN_REPOSITORY$"; - public MavenPathRelativizer() { - super(getNormalizedMavenRepositoryPath(), IDENTIFIER); + public MavenPathRelativizer(@NotNull String mavenRepositoryPath) { + super(mavenRepositoryPath, IDENTIFIER); } - private static String getNormalizedMavenRepositoryPath() { + public static @Nullable String getNormalizedMavenRepositoryPath() { String path = JpsMavenSettings.getMavenRepositoryPath(); - if (path != null) { - return PathRelativizerService.normalizePath(path); - } - return null; + return path == null ? null : PathRelativizerService.normalizePath(path); } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/PathRelativizerService.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/PathRelativizerService.java index 6a7d88d461e2..f643e520d6a6 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/PathRelativizerService.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/relativizer/PathRelativizerService.java @@ -2,6 +2,7 @@ package org.jetbrains.jps.incremental.relativizer; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.SystemInfoRt; import com.intellij.openapi.util.io.FileUtilRt; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; @@ -17,10 +18,7 @@ import org.jetbrains.jps.util.JpsPathUtil; import java.io.File; import java.nio.file.Path; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; public final class PathRelativizerService { @@ -29,7 +27,7 @@ public final class PathRelativizerService { private static final String PROJECT_DIR_IDENTIFIER = "$PROJECT_DIR$"; private static final String BUILD_DIR_IDENTIFIER = "$BUILD_DIR$"; - private final List relativizers; + private final PathRelativizer[] relativizers; private final Set unhandledPaths = Collections.synchronizedSet(new LinkedHashSet<>()); public PathRelativizerService(@Nullable String projectPath) { @@ -45,16 +43,12 @@ public final class PathRelativizerService { } public PathRelativizerService(@NotNull JpsProject project, @Nullable Boolean projectDirIsCaseSensitive) { - Set> javaSdks = project.getModules().stream() - .map(module -> module.getSdk(JpsJavaSdkType.INSTANCE)) - .filter(sdk -> sdk != null && sdk.getVersionString() != null && sdk.getHomePath() != null) - .collect(Collectors.toSet()); + Set> javaSdks = project.getModules().stream().map(module -> module.getSdk(JpsJavaSdkType.INSTANCE)) + .filter(sdk -> sdk != null && sdk.getVersionString() != null && sdk.getHomePath() != null).collect(Collectors.toSet()); File projectBaseDirectory = JpsModelSerializationDataService.getBaseDirectory(project); - relativizers = initialize(projectBaseDirectory == null ? null : projectBaseDirectory.getAbsolutePath(), - getBuildDirPath(project), - projectDirIsCaseSensitive, - javaSdks); + relativizers = initialize(projectBaseDirectory == null ? null : projectBaseDirectory.getAbsolutePath(), getBuildDirPath(project), + projectDirIsCaseSensitive, javaSdks); } @TestOnly @@ -111,19 +105,36 @@ public final class PathRelativizerService { } } - private static @NotNull List initialize(@Nullable String projectPath, - @Nullable String buildDirPath, - @Nullable Boolean projectDirIsCaseSensitive, - @Nullable Set> javaSdks) { + private static PathRelativizer[] initialize(@Nullable String projectPath, + @Nullable String buildDirPath, + @Nullable Boolean projectDirIsCaseSensitive, + @Nullable Set> javaSdks) { String normalizedProjectPath = projectPath == null ? null : normalizePath(projectPath); String normalizedBuildDirPath = buildDirPath == null ? null : normalizePath(buildDirPath); - return List.of( - new CommonPathRelativizer(normalizedBuildDirPath, BUILD_DIR_IDENTIFIER, projectDirIsCaseSensitive), - new CommonPathRelativizer(normalizedProjectPath, PROJECT_DIR_IDENTIFIER), - new JavaSdkPathRelativizer(javaSdks), - new MavenPathRelativizer(), - new GradlePathRelativizer() - ); + List result = new ArrayList<>(5); + if (normalizedBuildDirPath != null) { + result.add(new CommonPathRelativizer(normalizedBuildDirPath, BUILD_DIR_IDENTIFIER, projectDirIsCaseSensitive == null + ? SystemInfoRt.isFileSystemCaseSensitive + : projectDirIsCaseSensitive)); + } + if (normalizedProjectPath != null) { + result.add(new CommonPathRelativizer(normalizedProjectPath, PROJECT_DIR_IDENTIFIER)); + } + + if (javaSdks != null && !javaSdks.isEmpty()) { + result.add(new JavaSdkPathRelativizer(javaSdks)); + } + + String mavenRepositoryPath = MavenPathRelativizer.getNormalizedMavenRepositoryPath(); + if (mavenRepositoryPath != null) { + result.add(new MavenPathRelativizer(mavenRepositoryPath)); + } + + String gradleRepositoryPath = GradlePathRelativizer.initializeGradleRepositoryPath(); + if (gradleRepositoryPath != null) { + result.add(new GradlePathRelativizer(gradleRepositoryPath)); + } + return result.toArray(new PathRelativizer[0]); } static @NotNull String normalizePath(@NotNull String path) {