Fix multi module (#189)

* fix multi-module

* fix multi-module

Author: jxnu-liguobin

build.sbt

@@ -13,7 +13,7 @@ lazy val jbAnnotVersion        = "26.0.2"
 // https://youtrack.jetbrains.com/articles/IDEA-A-2100661679/IntelliJ-IDEA-2023.3-Latest-Builds
 // NOTE: Latest-Builds 233
 lazy val intellijVersion = "252.25557.131"
-lazy val pluginVersion   = s"0.8.2-$intellijVersion"
+lazy val pluginVersion   = s"0.8.3-$intellijVersion"
 
 ThisBuild / version := pluginVersion
 

src/main/scala/bitlap/sbt/analyzer/SbtDependencyAnalyzerContributor.scala

@@ -47,7 +47,7 @@ final class SbtDependencyAnalyzerContributor(project: Project) extends Dependenc
   private var organization: String = scala.compiletime.uninitialized
 
   @volatile
-  private var ideaModuleIdSbtModules: Map[String, String] = Map.empty
+  private var moduleIdArtifactIds: Map[String, String] = Map.empty
 
   private lazy val projects: ConcurrentHashMap[DependencyAnalyzerProject, ModuleNode] =
     ConcurrentHashMap[DependencyAnalyzerProject, ModuleNode]()
@@ -164,7 +164,7 @@ final class SbtDependencyAnalyzerContributor(project: Project) extends Dependenc
     val root         = DAModule(moduleData.getModuleName)
     root.putUserData(Module_Data, moduleData)
 
-    val rootDependency = DADependency(root, DefaultConfiguration, null, Collections.emptyList())
+    val rootDependency = DADependency(root, DEFAULT_CONFIGURATION, null, Collections.emptyList())
     dependencies.append(rootDependency)
     for (scopeNode <- scopeNodes.asScala) {
       val scope = scopeNode.toScope
@@ -248,18 +248,17 @@ final class SbtDependencyAnalyzerContributor(project: Project) extends Dependenc
     organization
   end getOrganization
 
-  private def getIdeaModuleIdSbtModules(project: Project): Map[String, String] =
-    if (ideaModuleIdSbtModules.nonEmpty) return ideaModuleIdSbtModules
+  private def getModuleIdArtifactIds(project: Project): Map[String, String] =
+    if (moduleIdArtifactIds.nonEmpty) return moduleIdArtifactIds
 
     // we don't actively delete configurations
-
     val settingsState = SettingsState.getSettings(project)
     if (!settingsState.sbtModules.isEmpty) return settingsState.sbtModules.asScala.toMap
 
-    ideaModuleIdSbtModules = SbtShellOutputAnalysisTask.sbtModuleNamesTask.executeCommand(project)
-    settingsState.sbtModules = ideaModuleIdSbtModules.asJava
-    ideaModuleIdSbtModules
-  end getIdeaModuleIdSbtModules
+    moduleIdArtifactIds = SbtShellOutputAnalysisTask.sbtModuleNamesTask.executeCommand(project)
+    settingsState.sbtModules = moduleIdArtifactIds.asJava
+    moduleIdArtifactIds
+  end getModuleIdArtifactIds
 
   private def getOrRefreshData(moduleData: ModuleData): JList[DependencyScopeNode] =
     // use to link dependencies between modules.
@@ -273,7 +272,7 @@ final class SbtDependencyAnalyzerContributor(project: Project) extends Dependenc
           project,
           getOrganization(project),
           projects.values().asScala.map(d => d.getModuleName -> d.getLinkedExternalProjectPath).toMap,
-          getIdeaModuleIdSbtModules(project)
+          getModuleIdArtifactIds(project)
         )
     )
     Option(result).getOrElse(Collections.emptyList())
@@ -368,8 +367,8 @@ object SbtDependencyAnalyzerContributor
     def loadDependencies(
       project: Project,
       organization: String,
-      ideaModuleNamePaths: Map[String, String],
-      ideaModuleIdSbtModules: Map[String, String]
+      moduleNamePaths: Map[String, String],
+      moduleIdArtifactIds: Map[String, String]
     ): JList[DependencyScopeNode] =
       val module   = findModule(project, moduleData)
       val moduleId = moduleData.getId.split(" ")(0)
@@ -394,16 +393,14 @@ object SbtDependencyAnalyzerContributor
           DependencyGraphFactory
             .getInstance(summon[DependencyGraphType])
             .buildDependencyTree(
-              ModuleContext(
+              AnalyzerContext(
                 file,
                 moduleId,
                 scope,
                 organization,
-                ideaModuleNamePaths,
-                module.isScalaJs,
-                module.isScalaNative,
-                if (ideaModuleIdSbtModules.isEmpty) Map(moduleId -> module.getName)
-                else ideaModuleIdSbtModules
+                moduleNamePaths,
+                if (moduleIdArtifactIds.isEmpty) Map(moduleId -> module.getName)
+                else moduleIdArtifactIds
               ),
               createRootScopeNode(scope, project)
             )
@@ -414,8 +411,8 @@ object SbtDependencyAnalyzerContributor
             moduleData,
             scope,
             organization,
-            ideaModuleNamePaths,
-            ideaModuleIdSbtModules
+            moduleNamePaths,
+            moduleIdArtifactIds
           )
         }
       end executeCommandOrReadExistsFile

src/main/scala/bitlap/sbt/analyzer/model/AnalyzerContext.scala

@@ -0,0 +1,13 @@
+package bitlap.sbt.analyzer.model
+
+import bitlap.sbt.analyzer.DependencyScopeEnum
+
+final case class AnalyzerContext(
+  analysisFile: String,
+  currentModuleId: String,
+  scope: DependencyScopeEnum,
+  organization: String,
+  moduleNamePathsCache: Map[String, String] = Map.empty,
+  moduleIdArtifactIdsCache: Map[String, String] = Map.empty, // sbt module name == sbt artifact name
+  isTest: Boolean = false
+)

src/main/scala/bitlap/sbt/analyzer/model/ModuleContext.scala

@@ -9,7 +9,7 @@ trait DependencyGraphParser {
   val dependencyGraphType: DependencyGraphType
 
   def buildDependencyTree(
-    context: ModuleContext,
+    context: AnalyzerContext,
     root: DependencyScopeNode
   ): DependencyScopeNode
 

src/main/scala/bitlap/sbt/analyzer/parsing/DependencyGraphParser.scala

@@ -61,7 +61,7 @@ final class DotDependencyGraphParser extends DependencyGraphParser:
 
   /** build tree for dependency analyzer view
    */
-  override def buildDependencyTree(context: ModuleContext, root: DependencyScopeNode): DependencyScopeNode = {
+  override def buildDependencyTree(context: AnalyzerContext, root: DependencyScopeNode): DependencyScopeNode = {
     val data                       = getDependencyRelations(context)
     val dependencies: Dependencies = data.orNull
     val depMap = data.map(_.dependencies.map(a => a.id.toString -> toDependencyNode(a)).toMap).getOrElse(Map.empty)
@@ -98,7 +98,7 @@ final class DotDependencyGraphParser extends DependencyGraphParser:
     parentChildrenMap: Map[String, List[Int]],
     depMap: Map[String, DependencyNode],
     relationLabelsMap: Map[String, String],
-    context: ModuleContext,
+    context: AnalyzerContext,
     relations: List[Relation]
   ): Unit = {
     val childIds = parentChildrenMap
@@ -127,7 +127,7 @@ final class DotDependencyGraphParser extends DependencyGraphParser:
 
   /** parse dot file, get graph data
    */
-  private def getDependencyRelations(context: ModuleContext): Option[Dependencies] =
+  private def getDependencyRelations(context: AnalyzerContext): Option[Dependencies] =
     val mutableGraph: MutableGraph = DotUtils.parseAsGraph(context)
     if (mutableGraph == null) None
     else

src/main/scala/bitlap/sbt/analyzer/parsing/DotDependencyGraphParser.scala

@@ -20,7 +20,7 @@ import analyzer.util.Notifications
 import guru.nidi.graphviz.attribute.validate.ValidatorEngine
 import guru.nidi.graphviz.model.MutableGraph
 import guru.nidi.graphviz.parse.Parser
-import model.ModuleContext
+import model.AnalyzerContext
 
 object DotUtils {
 
@@ -32,7 +32,7 @@ object DotUtils {
     Try(parser.read(new File(file))).getOrElse(null)
   }
 
-  def parseAsGraph(context: ModuleContext): MutableGraph = {
+  def parseAsGraph(context: AnalyzerContext): MutableGraph = {
     if (context.isTest) return parseAsGraphTestOnly(context.analysisFile)
     val file = context.analysisFile
     try {

src/main/scala/bitlap/sbt/analyzer/parsing/DotUtils.scala

@@ -36,14 +36,12 @@ final class DependencyDotTask extends SbtShellDependencyAnalysisTask:
       DependencyGraphFactory
         .getInstance(dependencyGraphType)
         .buildDependencyTree(
-          ModuleContext(
+          AnalyzerContext(
             file,
             moduleId,
             scope,
             organization,
             moduleNamePaths,
-            module.isScalaJs,
-            module.isScalaNative,
             sbtModuleNameMap
           ),
           createRootScopeNode(scope, project)

src/main/scala/bitlap/sbt/analyzer/task/DependencyDotTask.scala

@@ -6,6 +6,7 @@ package util
 import java.util.concurrent.atomic.AtomicLong
 
 import scala.jdk.CollectionConverters.*
+import scala.util.matching.Regex
 
 import bitlap.sbt.analyzer.model.*
 import bitlap.sbt.analyzer.parsing.*
@@ -25,17 +26,14 @@ import com.intellij.openapi.util.text.StringUtil
 
 object DependencyUtils {
 
-  final val DefaultConfiguration = toDAScope("default")
+  final val DEFAULT_CONFIGURATION = toDAScope("default")
 
-  private final val rootId     = new AtomicLong(0)
-  private final val artifactId = new AtomicLong(0)
+  private final val rootId       = new AtomicLong(0)
+  private final val artifactId   = new AtomicLong(0)
+  private val SBT_ARTIFACT_REGEX = "(.*):(.*):(.*)".r
 
-  private val SBT_ARTIFACT_REGEX      = "(.*):(.*):(.*)".r
-  private val SCALA_ARTIFACT_REGEX    = "(.*)_(.*)".r
-  private val NATIVE_ARTIFACT_PATTERN = "_native\\d(\\.\\d+)?_\\d(\\.\\d+)?"
-  private val SJS_ARTIFACT_PATTERN    = "_sjs\\d(\\.\\d+)?_\\d(\\.\\d+)?"
-  private val NATIVE_ARTIFACT_REGEX   = "(.*)(_native\\d(\\.\\d+)?)_(.*)".r
-  private val SJS_ARTIFACT_REGEX      = "(.*)(_sjs\\d(\\.\\d+)?)_(.*)".r
+  val SCALA_VERSION_PATTERN: Regex =
+    """^([a-zA-Z0-9-]+?)(?:_(?:sjs\d+(?:\.\d+)?|native\d*(?:\.\d+)?|2\.1[123]|3))+$""".r
 
   private final case class PlatformModule(
     module: String,
@@ -50,10 +48,10 @@ object DependencyUtils {
    *  and applying filtering logic, which is critical for dependency graph/tree operations as this node serves as the
    *  root of the structure.
    */
-  def isSelfNode(dn: DependencyNode, context: ModuleContext): Boolean = {
+  def isSelfNode(dn: DependencyNode, context: AnalyzerContext): Boolean = {
     dn.getDisplayName match
       case SBT_ARTIFACT_REGEX(group, artifact, _) =>
-        context.organization == group && isSelfArtifact(artifact, context)
+        context.organization == group && isSubModule(artifact, context)
       case _ => false
   }
 
@@ -96,7 +94,7 @@ object DependencyUtils {
   def appendChildrenAndFixProjectNodes[N <: DependencyNode](
     parentNode: N,
     nodes: Seq[DependencyNode],
-    context: ModuleContext
+    context: AnalyzerContext
   ): Unit = {
     parentNode.getDependencies.addAll(nodes.asJava)
     val moduleDependencies = nodes.filter(d => isProjectModule(d, context))
@@ -112,8 +110,8 @@ object DependencyUtils {
       val group      = artifact.map(_.group).getOrElse(Constants.EMPTY_STRING)
       // Use artifact to determine whether there are modules in the dependency.
       if (
-        context.ideaModuleIdSbtModuleNames.values
-          .exists(d => group == context.organization && toPlatformModule(artifactId).module == d)
+        context.moduleIdArtifactIdsCache.values
+          .exists(d => group == context.organization && getPlatformModule(artifactId) == d)
       ) {
         appendChildrenAndFixProjectNodes(
           node,
@@ -124,51 +122,40 @@ object DependencyUtils {
     }
   }
 
-  private def isSelfArtifact(artifact: String, context: ModuleContext): Boolean = {
-    // processing cross-platform, module name is not artifact!
+  private def isSubModule(maybeModule: String, context: AnalyzerContext): Boolean = {
+    // Handles the cross-platform, module name is not equals to artifact!
     val currentModuleName =
-      context.ideaModuleIdSbtModuleNames.getOrElse(
+      context.moduleIdArtifactIdsCache.getOrElse(
         context.currentModuleId,
-        context.ideaModuleIdSbtModuleNames.getOrElse(
+        context.moduleIdArtifactIdsCache.getOrElse(
           Constants.SINGLE_SBT_MODULE,
-          context.ideaModuleIdSbtModuleNames.getOrElse(Constants.ROOT_SBT_MODULE, context.currentModuleId)
+          context.moduleIdArtifactIdsCache.getOrElse(Constants.ROOT_SBT_MODULE, context.currentModuleId)
         )
       )
 
     // NOTE: we don't determine the Scala version number.
-    if (context.isScalaNative) {
-      val module = artifact.replaceAll(NATIVE_ARTIFACT_PATTERN, Constants.EMPTY_STRING)
-      currentModuleName.equalsIgnoreCase(module)
-    } else if (context.isScalaJs) {
-      val module = artifact.replaceAll(SJS_ARTIFACT_PATTERN, Constants.EMPTY_STRING)
-      currentModuleName.equalsIgnoreCase(module)
-    } else {
-      artifact match
-        case SCALA_ARTIFACT_REGEX(module, _) =>
-          currentModuleName.equalsIgnoreCase(module)
-        // it is a java project
-        case _ => artifact.equalsIgnoreCase(currentModuleName)
+    maybeModule match {
+      case SCALA_VERSION_PATTERN(module) => module.equalsIgnoreCase(currentModuleName)
+      case _                             => maybeModule.equalsIgnoreCase(currentModuleName)
     }
   }
 
-  private def toPlatformModule(artifact: String): PlatformModule = {
+  private def getPlatformModule(artifact: String): String = {
     artifact match
-      case SJS_ARTIFACT_REGEX(module, _, _, scalaVer)    => PlatformModule(module, scalaVer)
-      case NATIVE_ARTIFACT_REGEX(module, _, _, scalaVer) => PlatformModule(module, scalaVer)
-      case SCALA_ARTIFACT_REGEX(module, scalaVer)        => PlatformModule(module, scalaVer)
-      case _                                             => PlatformModule(artifact, Constants.EMPTY_STRING)
+      case SCALA_VERSION_PATTERN(module) => module
+      case _                             => artifact
   }
 
-  private def toProjectDependencyNode(dn: DependencyNode, context: ModuleContext): Option[DependencyNode] = {
+  private def toProjectDependencyNode(dn: DependencyNode, context: AnalyzerContext): Option[DependencyNode] = {
     val artifactInfo = getArtifactInfoFromDisplayName(dn.getDisplayName).orNull
     if (artifactInfo == null) return None
-    val sbtModuleName  = toPlatformModule(artifactInfo.artifact).module
-    val ideaModuleName = context.ideaModuleIdSbtModuleNames.find(_._2 == sbtModuleName).map(_._1)
+    val sbtModuleName  = getPlatformModule(artifactInfo.artifact)
+    val ideaModuleName = context.moduleIdArtifactIdsCache.find(_._2 == sbtModuleName).map(_._1)
 
     // Processing cross-platform, module name is not artifact
     // This is a project node, we need a module not an artifact to get project path!
 
-    val fixedCustomName = context.ideaModuleNamePaths.map { case (name, path) =>
+    val fixedCustomName = context.moduleNamePathsCache.map { case (name, path) =>
       if (name.exists(_ == ' '))
         name.toLowerCase.replace(' ', '-') -> path
       else
@@ -177,9 +164,9 @@ object DependencyUtils {
 
     val projectPath =
       ideaModuleName
-        .flatMap(m => context.ideaModuleNamePaths.get(m))
+        .flatMap(m => context.moduleNamePathsCache.get(m))
         .getOrElse(
-          context.ideaModuleNamePaths
+          context.moduleNamePathsCache
             .getOrElse(sbtModuleName, fixedCustomName.getOrElse(sbtModuleName.toLowerCase, Constants.EMPTY_STRING))
         )
 
@@ -201,14 +188,14 @@ object DependencyUtils {
     Some(p)
   }
 
-  private def isProjectModule(dn: DependencyNode, context: ModuleContext): Boolean = {
+  private def isProjectModule(dn: DependencyNode, context: AnalyzerContext): Boolean = {
     // module dependency
     val artifactInfo = getArtifactInfoFromDisplayName(dn.getDisplayName).orNull
     if (artifactInfo == null) return false
     if (artifactInfo.group != context.organization) return false
     // Use artifacts to determine if there are dependent modules
     val matchModule =
-      context.ideaModuleIdSbtModuleNames.values.filter(m => m == toPlatformModule(artifactInfo.artifact).module)
+      context.moduleIdArtifactIdsCache.values.filter(m => m == getPlatformModule(artifactInfo.artifact))
 
     matchModule.nonEmpty
 

src/main/scala/bitlap/sbt/analyzer/util/DependencyUtils.scala

@@ -1,6 +1,6 @@
 package bitlap.sbt.analyzer
 
-import bitlap.sbt.analyzer.model.ModuleContext
+import bitlap.sbt.analyzer.model.AnalyzerContext
 import bitlap.sbt.analyzer.parsing.{ DependencyGraphFactory, DependencyGraphType }
 
 import org.scalatest.flatspec.AnyFlatSpec
@@ -21,13 +21,13 @@ class DependencyGraphParserSpec extends AnyFlatSpec {
     root.setResolutionState(ResolutionState.RESOLVED)
 
     val ctx =
-      ModuleContext(
+      AnalyzerContext(
         getClass.getClassLoader.getResource("test.dot").getFile,
         "star-authority-protocol",
         DependencyScopeEnum.Compile,
         "fc.xuanwu.star",
-        ideaModuleNamePaths = Map.empty,
-        ideaModuleIdSbtModuleNames = Map.empty,
+        moduleNamePathsCache = Map.empty,
+        moduleIdArtifactIdsCache = Map.empty,
         isTest = true
       )