Discover plugin classes in lib/modules directory

intellij-plugin-structure/structure-intellij-classes/src/main/java/com/jetbrains/plugin/structure/intellij/classes/locator/LibModulesDirectoryLocator.kt

@@ -0,0 +1,40 @@
+package com.jetbrains.plugin.structure.intellij.classes.locator
+
+import com.jetbrains.plugin.structure.base.utils.isDirectory
+import com.jetbrains.plugin.structure.base.utils.isJar
+import com.jetbrains.plugin.structure.base.utils.isZip
+import com.jetbrains.plugin.structure.base.utils.listFiles
+import com.jetbrains.plugin.structure.classes.resolvers.Resolver
+import com.jetbrains.plugin.structure.classes.resolvers.buildJarOrZipFileResolvers
+import com.jetbrains.plugin.structure.intellij.plugin.IdePlugin
+import java.nio.file.Path
+
+class LibModulesDirectoryLocator(
+ private val readMode: Resolver.ReadMode,
+ private val fileOriginProvider: FileOriginProvider = LibModulesDirectoryOriginProvider
+) : ClassesLocator {
+
+ override val locationKey = LibModulesDirectoryKey
+
+ override fun findClasses(idePlugin: IdePlugin, pluginFile: Path): List<Resolver> {
+ val modulesDir = pluginFile.resolve("lib").resolve("modules")
+ if (!modulesDir.isDirectory) {
+ return emptyList()
+ }
+
+ val origin = fileOriginProvider.getFileOrigin(idePlugin, pluginFile)
+ val jarsOrZips = modulesDir.listFiles().filter { file -> file.isJar() || file.isZip() }
+
+ return buildJarOrZipFileResolvers(jarsOrZips, readMode, origin)
+ }
+}
+
+object LibModulesDirectoryKey : LocationKey {
+ override val name: String = "lib/modules directory"
+
+ override fun getLocator(readMode: Resolver.ReadMode) = LibModulesDirectoryLocator(readMode)
+}
+
+object LibModulesDirectoryOriginProvider : FileOriginProvider {
+ override fun getFileOrigin(idePlugin: IdePlugin, pluginFile: Path) = PluginFileOrigin.LibDirectory(idePlugin)
+}

intellij-plugin-structure/structure-intellij-classes/src/main/java/com/jetbrains/plugin/structure/intellij/classes/plugin/IdePluginClassesFinder.kt

@@ -17,6 +17,7 @@ import com.jetbrains.plugin.structure.classes.resolvers.Resolver
 import com.jetbrains.plugin.structure.intellij.classes.locator.ClassesDirectoryKey
 import com.jetbrains.plugin.structure.intellij.classes.locator.JarPluginKey
 import com.jetbrains.plugin.structure.intellij.classes.locator.LibDirectoryKey
+import com.jetbrains.plugin.structure.intellij.classes.locator.LibModulesDirectoryKey
 import com.jetbrains.plugin.structure.intellij.classes.locator.LocationKey
 import com.jetbrains.plugin.structure.intellij.extractor.ExtractorResult
 import com.jetbrains.plugin.structure.intellij.extractor.PluginExtractor
@@ -91,7 +92,7 @@ class IdePluginClassesFinder private constructor(
 
  companion object {
 
- val MAIN_CLASSES_KEYS = listOf(JarPluginKey, ClassesDirectoryKey, LibDirectoryKey)
+ val MAIN_CLASSES_KEYS = listOf(JarPluginKey, ClassesDirectoryKey, LibDirectoryKey, LibModulesDirectoryKey)
 
  fun findPluginClasses(
  idePlugin: IdePlugin,

intellij-plugin-verifier/verifier-test/src/test/java/com/jetbrains/pluginverifier/tests/PluginClasspathTest.kt

@@ -0,0 +1,95 @@
+package com.jetbrains.pluginverifier.tests
+
+import com.jetbrains.plugin.structure.base.plugin.PluginCreationResult
+import com.jetbrains.plugin.structure.base.plugin.PluginCreationSuccess
+import com.jetbrains.plugin.structure.base.utils.contentBuilder.ContentBuilder
+import com.jetbrains.plugin.structure.base.utils.contentBuilder.buildDirectory
+import com.jetbrains.plugin.structure.base.utils.contentBuilder.buildZipFile
+import com.jetbrains.plugin.structure.classes.resolvers.Resolver
+import com.jetbrains.plugin.structure.intellij.classes.locator.LibModulesDirectoryLocator
+import com.jetbrains.plugin.structure.intellij.classes.plugin.IdePluginClassesFinder
+import com.jetbrains.plugin.structure.intellij.plugin.IdePlugin
+import com.jetbrains.plugin.structure.intellij.plugin.IdePluginManager
+import com.jetbrains.pluginverifier.createPluginResolver
+import com.jetbrains.pluginverifier.tests.mocks.classBytes
+import com.jetbrains.pluginverifier.tests.mocks.descriptor
+import com.jetbrains.pluginverifier.tests.mocks.ideaPlugin
+import net.bytebuddy.ByteBuddy
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PluginClasspathTest : BasePluginTest() {
+ private val byteBuddy = ByteBuddy()
+
+ private fun buildPluginInZip(pluginContentBuilder: ContentBuilder.() -> Unit): PluginCreationResult<IdePlugin> {
+ val pluginFile = buildZipFile(temporaryFolder.newFile("plugin.zip").toPath(), pluginContentBuilder)
+ val ideManager = IdePluginManager.createManager()
+ return ideManager.createPlugin(pluginFile, validateDescriptor = true)
+ }
+
+ private fun buildPluginInDirectory(pluginContentBuilder: ContentBuilder.() -> Unit): PluginCreationResult<IdePlugin> {
+ val pluginFile = buildDirectory(temporaryFolder.newFolder("plugin").toPath(), pluginContentBuilder)
+ val ideManager = IdePluginManager.createManager()
+ return ideManager.createPlugin(pluginFile, validateDescriptor = true)
+ }
+
+ @Test
+ fun `classes in plugin JAR and in plugin lib-modules are discovered`() {
+ val pluginId = "pluginverifier"
+ val descriptor = ideaPlugin(pluginId, "Mock Classpath")
+ val result = buildPluginInZip {
+ dir(pluginId) {
+ dir("lib") {
+ zip("plugin.jar") {
+ descriptor(descriptor)
+ classBytes("SomeClass", byteBuddy)
+ }
+ dir("modules") {
+ zip("plugin-module.jar") {
+ classBytes("Module", byteBuddy)
+ }
+ }
+ }
+ }
+ }
+ assertTrue(result is PluginCreationSuccess)
+ val pluginCreated = result as PluginCreationSuccess
+
+ IdePluginClassesFinder.findPluginClasses(pluginCreated.plugin).use { classLocations ->
+ classLocations.createPluginResolver().use {
+ val pluginClasses = it.allClasses
+ assertEquals(2, pluginClasses.size)
+ assertTrue(pluginClasses.containsAll(setOf("SomeClass", "Module")))
+ }
+ }
+ }
+
+ @Test
+ fun `lib-modules directory locator discovers classes`() {
+ val pluginId = "pluginverifier"
+ val descriptor = ideaPlugin(pluginId, "Mock Classpath")
+ val result = buildPluginInDirectory {
+ dir("lib") {
+ zip("plugin.jar") {
+ descriptor(descriptor)
+ }
+ dir("modules") {
+ zip("plugin-module.jar") {
+ classBytes("Module", byteBuddy)
+ }
+ }
+ }
+ }
+
+ assertTrue(result is PluginCreationSuccess)
+ val pluginCreated = result as PluginCreationSuccess
+ val plugin = pluginCreated.plugin
+
+ val locator = LibModulesDirectoryLocator(Resolver.ReadMode.FULL)
+ val classes = locator.findClasses(plugin, plugin.originalFile!!)
+ .flatMap { it.allClasses }
+ assertEquals(1, classes.size)
+ assertEquals("Module", classes.first())
+ }
+}

intellij-plugin-verifier/verifier-test/src/test/java/com/jetbrains/pluginverifier/tests/mocks/PluginDescriptors.kt

@@ -0,0 +1,42 @@
+package com.jetbrains.pluginverifier.tests.mocks
+
+import com.jetbrains.plugin.structure.base.utils.contentBuilder.ContentBuilder
+import com.jetbrains.pluginverifier.verifiers.resolution.FullyQualifiedClassName
+import net.bytebuddy.ByteBuddy
+
+internal fun ideaPlugin(pluginId: String = "someid",
+ pluginName: String = "someName",
+ vendor: String = "vendor",
+ sinceBuild: String = "131.1",
+ untilBuild: String = "231.1",
+ description: String = "this description is looooooooooong enough") = """
+ <id>$pluginId</id>
+ <name>$pluginName</name>
+ <version>someVersion</version>
+ ""<vendor email="vendor.com" url="url">$vendor</vendor>""
+ <description>$description</description>
+ <change-notes>these change-notes are looooooooooong enough</change-notes>
+ <idea-version since-build="$sinceBuild" until-build="$untilBuild"/>
+ <depends>com.intellij.modules.platform</depends>
+ """
+
+internal fun ContentBuilder.descriptor(header: String) {
+ dir("META-INF") {
+ file("plugin.xml") {
+ """
+ <idea-plugin>
+ $header
+ </idea-plugin>
+ """
+ }
+ }
+}
+
+internal fun ContentBuilder.classBytes(className: FullyQualifiedClassName, byteBuddy: ByteBuddy) {
+ val dynamicType = byteBuddy
+ .subclass(Object::class.java)
+ .name(className)
+ .make()
+ val simpleName = dynamicType.typeDescription.simpleName
+ file("$simpleName.class", dynamicType.bytes)
+}