Removed packageSearch.compat module and caches due kotlinx.serialization/issues/1264

https://github.com/Kotlin/kotlinx.serialization/issues/1264

GitOrigin-RevId: 6840233938f822b48f4e2eb9a56e1139481195d4
This commit is contained in:
Lamberto Basti
2022-10-04 16:57:41 +02:00
committed by intellij-monorepo-bot
parent 951128f29d
commit 6ad0b8d22f
21 changed files with 130 additions and 220 deletions

1
.idea/modules.xml generated
View File

@@ -765,7 +765,6 @@
<module fileurl="file://$PROJECT_DIR$/platform/built-in-server/client/node-rpc-client/intellij.nodeRpcClient.iml" filepath="$PROJECT_DIR$/platform/built-in-server/client/node-rpc-client/intellij.nodeRpcClient.iml" />
<module fileurl="file://$PROJECT_DIR$/notebooks/visualization/intellij.notebooks.visualization.iml" filepath="$PROJECT_DIR$/notebooks/visualization/intellij.notebooks.visualization.iml" />
<module fileurl="file://$PROJECT_DIR$/plugins/package-search/intellij.packageSearch.iml" filepath="$PROJECT_DIR$/plugins/package-search/intellij.packageSearch.iml" />
<module fileurl="file://$PROJECT_DIR$/plugins/package-search/compat/intellij.packageSearch.compat.iml" filepath="$PROJECT_DIR$/plugins/package-search/compat/intellij.packageSearch.compat.iml" />
<module fileurl="file://$PROJECT_DIR$/plugins/package-search/gradle/intellij.packageSearch.gradle.iml" filepath="$PROJECT_DIR$/plugins/package-search/gradle/intellij.packageSearch.gradle.iml" />
<module fileurl="file://$PROJECT_DIR$/plugins/package-search/gradle/tooling/intellij.packageSearch.gradle.tooling.iml" filepath="$PROJECT_DIR$/plugins/package-search/gradle/tooling/intellij.packageSearch.gradle.tooling.iml" />
<module fileurl="file://$PROJECT_DIR$/plugins/package-search/kotlin/intellij.packageSearch.kotlin.iml" filepath="$PROJECT_DIR$/plugins/package-search/kotlin/intellij.packageSearch.kotlin.iml" />

View File

@@ -124,7 +124,6 @@ object CommunityRepositoryModules {
spec.withProjectLibrary("Gradle", LibraryPackMode.STANDALONE_SEPARATE)
},
plugin("intellij.packageSearch") { spec ->
spec.withModule("intellij.packageSearch.compat")
spec.withModule("intellij.packageSearch.gradle")
spec.withModule("intellij.packageSearch.gradle.tooling", "pkgs-tooling-extension.jar")
spec.withModule("intellij.packageSearch.maven")

View File

@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="FacetManager">
<facet type="kotlin-language" name="Kotlin">
<configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
<compilerSettings>
<option name="additionalArguments" value="-Xjvm-default=enable -Xuse-old-backend -opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi -opt-in=kotlin.ExperimentalStdlibApi -opt-in=kotlinx.coroutines.FlowPreview -opt-in=kotlin.time.ExperimentalTime" />
</compilerSettings>
<compilerArguments>
<stringArguments>
<stringArg name="jvmTarget" arg="17" />
<stringArg name="apiVersion" arg="1.5" />
<stringArg name="languageVersion" arg="1.5" />
</stringArguments>
<arrayArguments>
<arrayArg name="pluginClasspaths">
<args>$KOTLIN_BUNDLED$/lib/kotlinx-serialization-compiler-plugin.jar</args>
</arrayArg>
</arrayArguments>
</compilerArguments>
</configuration>
</facet>
</component>
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/resources" type="java-resource" />
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" packagePrefix="com.jetbrains.packagesearch" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="kotlin-stdlib-jdk8" level="project" />
<orderEntry type="library" name="kotlinx-serialization-core" level="project" />
<orderEntry type="library" name="package-search-api-models" level="project" />
<orderEntry type="library" name="package-search-version-utils" level="project" />
<orderEntry type="module" module-name="intellij.platform.core" />
</component>
</module>

View File

@@ -1 +0,0 @@
packagesearch.ui.missingVersion=[not set]

View File

@@ -1,32 +0,0 @@
/*******************************************************************************
* Copyright 2000-2022 JetBrains s.r.o. and contributors.
*
* 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 com.jetbrains.packagesearch.intellij.plugin
import com.intellij.DynamicBundle
import org.jetbrains.annotations.Nls
import org.jetbrains.annotations.PropertyKey
private const val BUNDLE_NAME = "messages.packageSearchCompatBundle"
internal object PackageSearchCompatBundle : DynamicBundle(BUNDLE_NAME) {
@Nls
fun message(
@PropertyKey(resourceBundle = BUNDLE_NAME) key: String,
vararg params: Any
): String = getMessage(key, *params)
}

View File

@@ -48,7 +48,6 @@
<orderEntry type="library" name="package-search-api-models" level="project" />
<orderEntry type="library" name="package-search-version-utils" level="project" />
<orderEntry type="module" module-name="intellij.java.psi" />
<orderEntry type="module" module-name="intellij.packageSearch.compat" />
<orderEntry type="module" module-name="intellij.platform.analysis" />
<orderEntry type="module" module-name="intellij.platform.builtInServer.impl" />
<orderEntry type="module" module-name="intellij.platform.core" />

View File

@@ -93,10 +93,10 @@ Supports Maven and Gradle projects.
serviceImplementation="com.jetbrains.packagesearch.intellij.plugin.configuration.PackageSearchGeneralConfiguration"/>
<projectService
serviceImplementation="com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageSearchProjectCachesService"/>
serviceImplementation="com.jetbrains.packagesearch.intellij.plugin.data.PackageSearchProjectCachesService"/>
<applicationService
serviceImplementation="com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageSearchCachesService"/>
serviceImplementation="com.jetbrains.packagesearch.intellij.plugin.data.PackageSearchCachesService"/>
<recoveryAction implementation="com.jetbrains.packagesearch.intellij.plugin.extensibility.DeletePackageSearchProjectCachesAction"/>

View File

@@ -132,9 +132,8 @@ packagesearch.ui.toolwindow.link.readme.capitalized=Readme
packagesearch.ui.toolwindow.link.readme=readme
packagesearch.ui.toolwindow.link.scm.capitalized=Sources
packagesearch.ui.toolwindow.link.scm=Sources
packagesearch.ui.toolwindow.modulesTree.empty=No modules to display.
packagesearch.ui.missingVersion=[not set]
packagesearch.ui.toolwindow.packages.actions.set=Set
packagesearch.ui.toolwindow.packages.actions.install=Add
packagesearch.ui.toolwindow.packages.actions.upgrade=Upgrade

View File

@@ -42,6 +42,9 @@ import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.buffer
import kotlinx.coroutines.flow.scan
import kotlinx.coroutines.future.await
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

View File

@@ -0,0 +1,54 @@
package com.jetbrains.packagesearch.intellij.plugin.data
import com.intellij.openapi.Disposable
import com.intellij.openapi.application.appSystemDir
import com.intellij.util.io.delete
import com.intellij.util.io.exists
import com.intellij.util.io.readText
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.PackageVersion
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.NormalizedPackageVersion
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageVersionNormalizer
import com.jetbrains.packagesearch.intellij.plugin.util.CoroutineLRUCache
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.launch
import kotlinx.serialization.json.Json
import java.nio.file.Files
import kotlin.io.path.writeText
internal class PackageSearchCachesService : Disposable {
private val normalizerCacheFile = appSystemDir.resolve("caches/pkgs/normalizedVersions.json")
private val json = Json {
prettyPrint = true
allowStructuredMapKeys = true
}
private val normalizerCache: CoroutineLRUCache<PackageVersion.Named, NormalizedPackageVersion<PackageVersion.Named>> =
// TODO compilation bug due to https://github.com/Kotlin/kotlinx.serialization/issues/1264
// normalizerCacheFile.takeIf { it.exists() }
// ?.runCatching {
// json.decodeFromString(
// CoroutineLRUCache.serializer<PackageVersion.Named, NormalizedPackageVersion<PackageVersion.Named>>(),
// readText()
// )
// }
// ?.getOrNull()
// ?:
CoroutineLRUCache(4_000)
val normalizer = PackageVersionNormalizer(normalizerCache)
override fun dispose() {
// TODO compilation bug due to https://github.com/Kotlin/kotlinx.serialization/issues/1264
// normalizerCacheFile
// .apply { if (!parent.exists()) Files.createDirectories(parent) }
// .writeText(json.encodeToString(CoroutineLRUCache.serializer(), normalizerCache))
}
suspend fun clear() = coroutineScope {
launch { normalizerCache.clear() }
launch(Dispatchers.IO) { normalizerCacheFile.delete() }
}
}

View File

@@ -0,0 +1,42 @@
package com.jetbrains.packagesearch.intellij.plugin.data
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.getProjectDataPath
import com.intellij.util.io.createDirectories
import com.intellij.util.io.delete
import com.intellij.util.io.exists
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.InstalledDependency
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.UiPackageModel
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.panels.management.packages.PackagesListPanel
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.panels.management.packages.UiPackageModelCacheKey
import com.jetbrains.packagesearch.intellij.plugin.util.CoroutineLRUCache
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.launch
import org.jetbrains.packagesearch.api.v2.ApiPackagesResponse
import org.jetbrains.packagesearch.api.v2.ApiStandardPackage
internal class PackageSearchProjectCachesService(project: Project) {
val searchCache: CoroutineLRUCache<PackagesListPanel.SearchCommandModel, ApiPackagesResponse<ApiStandardPackage, ApiStandardPackage.ApiStandardVersion>> =
CoroutineLRUCache(200)
val searchPackageModelCache: CoroutineLRUCache<UiPackageModelCacheKey, UiPackageModel.SearchResult> =
CoroutineLRUCache(1000)
val installedDependencyCache: CoroutineLRUCache<InstalledDependency, ApiStandardPackage> =
CoroutineLRUCache(500)
val projectCacheDirectory = project.getProjectDataPath("pkgs")
.also { if (!it.exists()) it.createDirectories() }
suspend fun clear() = coroutineScope {
launch { searchCache.clear() }
launch { searchPackageModelCache.clear() }
launch { installedDependencyCache.clear() }
launch(Dispatchers.IO) {
projectCacheDirectory.delete(true)
projectCacheDirectory.createDirectories()
}
}
}

View File

@@ -21,7 +21,8 @@ import org.jetbrains.packagesearch.api.v2.ApiStandardPackage
internal data class InstalledDependency(val groupId: String, val artifactId: String) {
val coordinatesString = "$groupId:$artifactId"
val coordinatesString
get() = "$groupId:$artifactId"
companion object {

View File

@@ -79,11 +79,7 @@ internal sealed class PackageModel(
) = coroutineScope {
val remoteVersions = async { evaluateRemoteVersions(remoteInfo, normalizer) }
val latestInstalledVersion = async {
usageInfo.asFlow()
.map { it.declaredVersion }
.map { normalizer.parse(it) }
.toList()
.maxOrNull()
usageInfo.map { it.declaredVersion }.maxOfOrNull { normalizer.parse(it) }
?: error("An installed package must always have at least one usage")
}
val declaredVersions = async {

View File

@@ -101,7 +101,7 @@ internal class ProjectDataProvider(
"Found ${dependencies.count() - packagesToFetch.count()} packages in cache, still need to fetch ${packagesToFetch.count()} from API"
}
val fetchedPackages = packagesToFetch.asSequence()
packagesToFetch.asSequence()
.map { dependency -> dependency.coordinatesString }
.chunked(size = 25)
.asFlow()
@@ -116,8 +116,7 @@ internal class ProjectDataProvider(
}
.toList()
.flatten()
for (v2Package in fetchedPackages) {
.forEach { v2Package ->
val dependency = InstalledDependency.from(v2Package)
packageCache.put(dependency, v2Package)
remoteInfoByDependencyMap[dependency] = v2Package

View File

@@ -16,93 +16,13 @@
package com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions
import com.intellij.openapi.Disposable
import com.intellij.openapi.application.appSystemDir
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.getProjectDataPath
import com.intellij.util.io.createDirectories
import com.intellij.util.io.delete
import com.intellij.util.io.exists
import com.intellij.util.io.readText
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.InstalledDependency
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.PackageVersion
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.PackagesToUpgrade
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.UiPackageModel
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.operations.PackageSearchOperation
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.NormalizedPackageVersion.Garbage
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.NormalizedPackageVersion.Semantic
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.NormalizedPackageVersion.TimestampLike
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.panels.management.packages.PackagesListPanel
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.panels.management.packages.UiPackageModelCacheKey
import com.jetbrains.packagesearch.intellij.plugin.util.CoroutineLRUCache
import com.jetbrains.packagesearch.intellij.plugin.util.nullIfBlank
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.Json
import org.jetbrains.packagesearch.api.v2.ApiPackagesResponse
import org.jetbrains.packagesearch.api.v2.ApiStandardPackage
import java.nio.file.Files
import kotlin.io.path.writeText
internal class PackageSearchCachesService : Disposable {
private val persistentCacheFile = appSystemDir.resolve("caches/pkgs/normalizedVersions.json")
private val json = Json {
prettyPrint = true
allowStructuredMapKeys = true
}
private val normalizerCache: CoroutineLRUCache<PackageVersion.Named, NormalizedPackageVersion<PackageVersion.Named>> =
persistentCacheFile.takeIf { it.exists() }
?.runCatching {
json.decodeFromString(
CoroutineLRUCache.serializer<PackageVersion.Named, NormalizedPackageVersion<PackageVersion.Named>>(),
readText()
)
}
?.getOrNull()
?: CoroutineLRUCache(4_000)
val normalizer = PackageVersionNormalizer(normalizerCache)
override fun dispose() {
persistentCacheFile
.apply { if (!parent.exists()) Files.createDirectories(parent) }
.writeText(json.encodeToString(CoroutineLRUCache.serializer(), normalizerCache))
}
suspend fun clear() = coroutineScope {
launch { normalizerCache.clear() }
launch { persistentCacheFile.delete() }
}
}
internal class PackageSearchProjectCachesService(project: Project) {
val searchCache: CoroutineLRUCache<PackagesListPanel.SearchCommandModel, ApiPackagesResponse<ApiStandardPackage, ApiStandardPackage.ApiStandardVersion>> =
CoroutineLRUCache(200)
val searchPackageModelCache: CoroutineLRUCache<UiPackageModelCacheKey, UiPackageModel.SearchResult> =
CoroutineLRUCache(1000)
val installedDependencyCache: CoroutineLRUCache<InstalledDependency, ApiStandardPackage> =
CoroutineLRUCache(500)
val projectCacheDirectory = project.getProjectDataPath("pkgs")
.also { if (!it.exists()) it.createDirectories() }
suspend fun clear() = coroutineScope {
launch { searchCache.clear() }
launch { searchPackageModelCache.clear() }
launch { installedDependencyCache.clear() }
launch {
projectCacheDirectory.delete(true)
projectCacheDirectory.createDirectories()
}
}
}
internal class PackageVersionNormalizer(
private val versionsCache: CoroutineLRUCache<PackageVersion.Named, NormalizedPackageVersion<PackageVersion.Named>> = CoroutineLRUCache(2_000)

View File

@@ -47,6 +47,7 @@ import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ProducerScope
import kotlinx.coroutines.channels.SendChannel
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.channels.produce
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
@@ -63,12 +64,14 @@ import kotlinx.coroutines.flow.mapLatest
import kotlinx.coroutines.flow.merge
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.flow.scan
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.future.await
import kotlinx.coroutines.job
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.selects.select
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
@@ -137,32 +140,8 @@ internal fun <T> Flow<T>.throttle(time: Duration) =
internal inline fun <reified T, reified R> Flow<T>.modifiedBy(
modifierFlow: Flow<R>,
crossinline transform: suspend (T, R) -> T
): Flow<T> = flow {
coroutineScope {
val queue = Channel<Any?>(capacity = 1)
val mutex = Mutex(locked = true)
this@modifiedBy.onEach {
queue.send(it)
if (mutex.isLocked) mutex.unlock()
}.launchIn(this)
mutex.lock()
modifierFlow.onEach { queue.send(it) }.launchIn(this)
var currentState: T = queue.receive() as T
emit(currentState)
for (e in queue) {
when (e) {
is T -> currentState = e
is R -> currentState = transform(currentState, e)
else -> continue
}
emit(currentState)
}
}
}
noinline transform: suspend (T, R) -> T
): Flow<T> = flatMapLatest { modifierFlow.scan(it, transform) }
internal fun <T, R> Flow<T>.mapLatestTimedWithLoading(
loggingContext: String,
@@ -374,15 +353,14 @@ fun <A, B, C, Z> combineLatest(
) = combine(flowA, flowB, flowC) { a, b, c -> CombineLatest3(a, b, c) }
.mapLatest(transform)
fun <T> Flow<T>.pauseOn(flow: Flow<Boolean>): Flow<T> = channelFlow {
val buffer = Channel<T>()
onEach { buffer.send(it) }.launchIn(this)
flow.flatMapLatest { if (!it) EMPTY_UNCLOSED_FLOW else buffer.receiveAsFlow() }
.onEach { send(it) }
.launchIn(this)
awaitClose { buffer.close() }
fun <T> Flow<T>.pauseOn(flow: Flow<Boolean>): Flow<T> = flow {
coroutineScope {
val buffer = produce { collect { send(it) } }
flow.flatMapLatest { isOpen -> if (isOpen) buffer.receiveAsFlow() else EMPTY_UNCLOSED_FLOW }
.collect { emit(it) }
}
}
private val EMPTY_UNCLOSED_FLOW = channelFlow<Nothing> {
awaitClose()
private val EMPTY_UNCLOSED_FLOW = flow<Nothing> {
suspendCancellableCoroutine { }
}

View File

@@ -9,9 +9,6 @@ import com.intellij.ide.ui.LafManager
import com.intellij.ide.ui.LafManagerListener
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.components.service
import com.intellij.openapi.extensions.ExtensionPointListener
import com.intellij.openapi.extensions.ExtensionPointName
import com.intellij.openapi.extensions.PluginDescriptor
import com.intellij.openapi.module.Module
import com.intellij.openapi.module.ModuleManager
import com.intellij.openapi.project.DumbService
@@ -34,12 +31,11 @@ import com.jetbrains.packagesearch.intellij.plugin.lifecycle.PackageSearchLifecy
import com.jetbrains.packagesearch.intellij.plugin.ui.PkgsUiCommandsService
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.UiStateModifier
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.UiStateSource
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageSearchCachesService
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageSearchProjectCachesService
import com.jetbrains.packagesearch.intellij.plugin.data.PackageSearchCachesService
import com.jetbrains.packagesearch.intellij.plugin.data.PackageSearchProjectCachesService
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.versions.PackageVersionNormalizer
import kotlinx.coroutines.channels.ProducerScope
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.channels.trySendBlocking
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.distinctUntilChanged

View File

@@ -17,7 +17,7 @@
package com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models
import com.intellij.util.text.VersionComparatorUtil
import com.jetbrains.packagesearch.intellij.plugin.PackageSearchCompatBundle
import com.jetbrains.packagesearch.intellij.plugin.PackageSearchBundle
import com.jetbrains.packagesearch.intellij.plugin.util.versionTokenPriorityProvider
import kotlinx.serialization.Serializable
import org.jetbrains.annotations.Nls
@@ -46,7 +46,7 @@ sealed class PackageVersion : Comparable<PackageVersion> {
override val releasedAt: Long? = null
@Nls
override val displayName = PackageSearchCompatBundle.message("packagesearch.ui.missingVersion")
override val displayName = PackageSearchBundle.message("packagesearch.ui.missingVersion")
@NonNls
override fun toString() = "[Missing version]"

View File

@@ -19,13 +19,13 @@ package com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.version
import com.intellij.util.text.VersionComparatorUtil
import com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models.PackageVersion
import com.jetbrains.packagesearch.intellij.plugin.util.versionTokenPriorityProvider
import kotlinx.serialization.Serializable
@Serializable
sealed class NormalizedPackageVersion<T : PackageVersion>(
val originalVersion: T
) : Comparable<NormalizedPackageVersion<*>> {
companion object
val versionName: String
get() = originalVersion.versionName
@@ -38,7 +38,6 @@ sealed class NormalizedPackageVersion<T : PackageVersion>(
val releasedAt: Long?
get() = originalVersion.releasedAt
@Serializable
data class Semantic(
private val original: PackageVersion.Named,
val semanticPart: String,
@@ -95,7 +94,6 @@ sealed class NormalizedPackageVersion<T : PackageVersion>(
}
}
@Serializable
data class TimestampLike(
private val original: PackageVersion.Named,
val timestampPrefix: String,
@@ -127,7 +125,6 @@ sealed class NormalizedPackageVersion<T : PackageVersion>(
}
}
@Serializable
data class Garbage(
private val original: PackageVersion.Named
) : NormalizedPackageVersion<PackageVersion.Named>(original) {
@@ -149,7 +146,6 @@ sealed class NormalizedPackageVersion<T : PackageVersion>(
}
}
@Serializable
object Missing : NormalizedPackageVersion<PackageVersion.Missing>(PackageVersion.Missing) {
override fun compareTo(other: NormalizedPackageVersion<*>): Int =