support multiple sources of annotations artifacts IDEA-201598

look for '-annotations' artifacts by original "groupId:artifactId" (when provided by library author) and by modified "groupId:artifactId-annotations" (when provided by third party)
2025-12-16 14:23:28 +07:00 · 2018-11-02 13:49:55 +03:00
parent a4b60eddd5
commit b47ccfc131
5 changed files with 69 additions and 14 deletions
--- a/aether-dependency-resolver/src/org/jetbrains/idea/maven/aether/ArtifactKind.java
+++ b/aether-dependency-resolver/src/org/jetbrains/idea/maven/aether/ArtifactKind.java
@@ -21,7 +21,7 @@ import java.util.EnumSet;

 public enum ArtifactKind {
  ARTIFACT("", "jar"), SOURCES("sources", "jar"), JAVADOC("javadoc", "jar"),
-  ANNOTATIONS("", "zip"), AAR_ARTIFACT("", "aar");
+  ANNOTATIONS("annotations", "zip"), AAR_ARTIFACT("", "aar");

  private final String myClassifier;
  private final String myExtension;
--- a/java/idea-ui/src/com/intellij/jarRepository/ExternalAnnotationsRepositoryResolver.kt
+++ b/java/idea-ui/src/com/intellij/jarRepository/ExternalAnnotationsRepositoryResolver.kt
@@ -28,8 +28,8 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
  }

  override fun resolve(project: Project, library: Library, mavenId: String?): Library {
-    val mavenLibDescriptor = extractDescriptor(mavenId, library) ?: return library
-    val roots = JarRepositoryManager
+    var mavenLibDescriptor = extractDescriptor(mavenId, library, false) ?: return library
+    var roots = JarRepositoryManager
      .loadDependenciesSync(project,
                             mavenLibDescriptor,
                             setOf(ArtifactKind.ANNOTATIONS),
@@ -37,6 +37,17 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
                             null)
      as MutableList<OrderRoot>?

+    if (roots == null || roots.isEmpty()) {
+      mavenLibDescriptor = extractDescriptor(mavenId, library, true) ?: return library
+      roots = JarRepositoryManager
+        .loadDependenciesSync(project,
+                              mavenLibDescriptor,
+                              setOf(ArtifactKind.ANNOTATIONS),
+                              null,
+                              null)
+        as MutableList<OrderRoot>?
+    }
+
    invokeAndWaitIfNeed {
      updateLibrary(roots, mavenLibDescriptor, library)
    }
@@ -45,7 +56,7 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
  }

  override fun resolveAsync(project: Project, library: Library, mavenId: String?): Promise<Library> {
-    val mavenLibDescriptor = extractDescriptor(mavenId, library) ?: return Promise.resolve(library)
+    val mavenLibDescriptor = extractDescriptor(mavenId, library, false) ?: return Promise.resolve(library)

    return JarRepositoryManager.loadDependenciesAsync(project,
                                               mavenLibDescriptor,
@@ -53,12 +64,30 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
                                               null,
                                               null)
      .thenAsync { roots ->
+        if (roots == null || roots.isEmpty()) {
+          val patchedDescriptor = extractDescriptor(mavenId, library, true) ?: return@thenAsync Promise.resolve(library)
+          val promise2 = JarRepositoryManager.loadDependenciesAsync(project,
+                                                     patchedDescriptor,
+                                                     setOf(ArtifactKind.ANNOTATIONS),
+                                                     null,
+                                                     null)
+            .thenAsync { moreRoots ->
+              val morePromise = AsyncPromise<Library>()
+              ApplicationManager.getApplication().invokeLater {
+                updateLibrary(moreRoots, patchedDescriptor, library)
+                morePromise.setResult(library)
+              }
+              morePromise
+            }
+           promise2
+        } else {
        val promise = AsyncPromise<Library>()
        ApplicationManager.getApplication().invokeLater {
          updateLibrary(roots, mavenLibDescriptor, library)
          promise.setResult(library)
        }
        promise
+        }
      }
  }

@@ -80,10 +109,15 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
  }

  private fun extractDescriptor(mavenId: String?,
-                                library: Library): JpsMavenRepositoryLibraryDescriptor? = when {
-    mavenId != null -> JpsMavenRepositoryLibraryDescriptor(patchArtifactId(mavenId), false, emptyList())
+                                library: Library,
+                                patched: Boolean): JpsMavenRepositoryLibraryDescriptor? = when {
+    mavenId != null -> JpsMavenRepositoryLibraryDescriptor(
+      if (patched) patchArtifactId(mavenId) else mavenId,
+      false, emptyList()
+    )
    library is LibraryEx  -> (library.properties as? RepositoryLibraryProperties)
-      ?.run { JpsMavenRepositoryLibraryDescriptor(groupId, "$artifactId-annotations", version) }
+      ?.run { JpsMavenRepositoryLibraryDescriptor(groupId,
+                                                   if (patched) "$artifactId-annotations" else artifactId, version) }
    else -> null
  }

--- a/java/idea-ui/testSrc/com/intellij/jarRepository/ExternalAnnotationsRepositoryResolverTest.kt
+++ b/java/idea-ui/testSrc/com/intellij/jarRepository/ExternalAnnotationsRepositoryResolverTest.kt
@@ -91,6 +91,24 @@ class ExternalAnnotationsRepositoryResolverTest: UsefulTestCase() {
    assertTrue(library.getFiles(AnnotationOrderRootType.getInstance()).isNotEmpty())
  }

+  @Test fun testThirdPartyAnnotationsResolution() {
+    val resolver = ExternalAnnotationsRepositoryResolver()
+    val libraryTable = LibraryTablesRegistrar.getInstance().libraryTable
+    val library = WriteAction.compute<Library, RuntimeException> { libraryTable.createLibrary("NewLibrary") }
+
+    RemoteRepositoriesConfiguration.getInstance(myProject).repositories = listOf(myTestRepo)
+
+    MavenRepoFixture(myMavenRepo).apply {
+      addLibraryArtifact(version = "1.0")
+      addAnnotationsArtifact(artifact = "myArtifact-annotations", version = "1.0")
+      generateMavenMetadata("myGroup", "myArtifact")
+      generateMavenMetadata("myGroup", "myArtifact-annotations")
+    }
+
+    resolver.resolve(myProject, library, "myGroup:myArtifact:1.0")
+    assertTrue(library.getFiles(AnnotationOrderRootType.getInstance()).isNotEmpty())
+  }
+

  @Test fun `test select annotations artifact when newer library artifacts are available`() {
    val resolver = ExternalAnnotationsRepositoryResolver()
@@ -103,8 +121,11 @@ class ExternalAnnotationsRepositoryResolverTest: UsefulTestCase() {
      addLibraryArtifact(version = "1.0")
      addAnnotationsArtifact(version = "1.0")
      addAnnotationsArtifact(version = "1.0-an1")
+      addAnnotationsArtifact(artifact = "myArtifact-annotations", version = "1.0")
+      addAnnotationsArtifact(artifact = "myArtifact-annotations", version = "1.0-an1")
      addLibraryArtifact(version = "1.1")
      generateMavenMetadata("myGroup", "myArtifact")
+      generateMavenMetadata("myGroup", "myArtifact-annotations")
    }

    resolver.resolve(myProject, library, "myGroup:myArtifact:1.1")
@@ -130,7 +151,7 @@ class ExternalAnnotationsRepositoryResolverTest: UsefulTestCase() {
    }

    resolver.resolve(myProject, library, "myGroup:myArtifact:1.0")
-    assertTrue(library.getUrls(AnnotationOrderRootType.getInstance()).single().endsWith("myGroup/myArtifact-annotations/1.0-an1/myArtifact-annotations-1.0-an1.zip!/"))
+    assertTrue(library.getUrls(AnnotationOrderRootType.getInstance()).single().endsWith("myGroup/myArtifact/1.0-an1/myArtifact-1.0-an1-annotations.zip!/"))
  }

  private fun <T> getResult(promise: Promise<T>): T? {
--- a/java/idea-ui/testSrc/com/intellij/jarRepository/JarRepositoryManagerTest.kt
+++ b/java/idea-ui/testSrc/com/intellij/jarRepository/JarRepositoryManagerTest.kt
@@ -62,7 +62,7 @@ class JarRepositoryManagerTest : UsefulTestCase() {
      generateMavenMetadata("myGroup", "myArtifact")
    }

-    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact-annotations", "1.0")
+    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact", "1.0")
    val promise: Promise<MutableList<OrderRoot>> = JarRepositoryManager.loadDependenciesAsync(myProject, description, setOf(ArtifactKind.ANNOTATIONS),
                                                                                              listOf(myTestRepo), null)
    val result: List<OrderRoot>? = getResultingRoots(promise)
@@ -79,7 +79,7 @@ class JarRepositoryManagerTest : UsefulTestCase() {
      generateMavenMetadata("myGroup", "myArtifact")
    }

-    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact-annotations", "1.0",
+    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact", "1.0",
                                                          false, emptyList())
    val promise: Promise<MutableList<OrderRoot>> = JarRepositoryManager.loadDependenciesAsync(myProject, description, setOf(ArtifactKind.ANNOTATIONS),
                                                                                              listOf(myTestRepo), null)
@@ -99,7 +99,7 @@ class JarRepositoryManagerTest : UsefulTestCase() {
    }


-    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact-annotations", "1.0")
+    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact", "1.0")
    val promise: Promise<MutableList<OrderRoot>> = JarRepositoryManager.loadDependenciesAsync(myProject, description, setOf(ArtifactKind.ANNOTATIONS),
                                                                                              listOf(myTestRepo), null)
    val result: List<OrderRoot>? = getResultingRoots(promise)
@@ -121,7 +121,7 @@ class JarRepositoryManagerTest : UsefulTestCase() {
      name
    }

-    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact-annotations", "2.5")
+    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact", "2.5")
    val promise: Promise<MutableList<OrderRoot>> = JarRepositoryManager.loadDependenciesAsync(myProject, description, setOf(ArtifactKind.ANNOTATIONS),
                                                                                              listOf(myTestRepo), null)
    val result: List<OrderRoot>? = getResultingRoots(promise)
@@ -145,7 +145,7 @@ class JarRepositoryManagerTest : UsefulTestCase() {
      name
    }

-    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact-annotations", "[2.0, 2.1)")
+    val description = JpsMavenRepositoryLibraryDescriptor("myGroup", "myArtifact", "[2.0, 2.1)")
    val promise: Promise<MutableList<OrderRoot>> = JarRepositoryManager.loadDependenciesAsync(myProject, description, setOf(ArtifactKind.ANNOTATIONS),
                                                                                              listOf(myTestRepo), null)
    val result: List<OrderRoot>? = getResultingRoots(promise)
--- a/java/idea-ui/testSrc/com/intellij/jarRepository/MavenRepoFixture.kt
+++ b/java/idea-ui/testSrc/com/intellij/jarRepository/MavenRepoFixture.kt
@@ -17,7 +17,7 @@ class MavenRepoFixture(private val myMavenRepo: File) {
  public fun addAnnotationsArtifact(group: String = "myGroup",
                                    artifact: String = "myArtifact",
                                    version: String)
-    : String = File(myMavenRepo, "$group/$artifact-annotations/$version/$artifact-annotations-$version.zip")
+    : String = File(myMavenRepo, "$group/$artifact/$version/$artifact-$version-annotations.zip")
    .apply {
      parentFile.mkdirs()
      writeText("Fake annotations artifact")