[prod/test sources] finished

extractor/src/main/scala/org/jetbrains/sbt/Options.scala

@@ -5,7 +5,8 @@ final case class Options(download: Boolean = false,
                          resolveJavadocClassifiers: Boolean = false,
                          resolveSbtClassifiers: Boolean = false,
                          prettyPrint: Boolean = false,
-                         insertProjectTransitiveDependencies: Boolean = true)
+                         insertProjectTransitiveDependencies: Boolean = true,
+                         separateProdAndTestSources: Boolean = false)
 
 object Options {
 
@@ -26,7 +27,8 @@ object Options {
     resolveJavadocClassifiers = options.contains(Keys.ResolveJavadocClassifiers),
     resolveSbtClassifiers = options.contains(Keys.ResolveSbtClassifiers),
     prettyPrint = options.contains(Keys.PrettyPrint),
-    insertProjectTransitiveDependencies = options.contains(Keys.InsertProjectTransitiveDependencies)
+    insertProjectTransitiveDependencies = options.contains(Keys.InsertProjectTransitiveDependencies),
+    separateProdAndTestSources = options.contains(Keys.SeparateProdAndTestSources)
   )
 
   object Keys {
@@ -36,6 +38,7 @@ object Options {
     val ResolveSbtClassifiers = "resolveSbtClassifiers"
     val PrettyPrint = "prettyPrint"
     val InsertProjectTransitiveDependencies = "insertProjectTransitiveDependencies"
+    val SeparateProdAndTestSources = "separateProdAndTestSources"
   }
 }
 

extractor/src/main/scala/org/jetbrains/sbt/extractors/ProjectExtractor.scala

@@ -4,7 +4,7 @@ package extractors
 import org.jetbrains.sbt.structure._
 import sbt.Def.Initialize
 import sbt.jetbrains.keysAdapterEx
-import sbt.{Def, File, Configuration => _, _}
+import sbt.{Def, File, Configuration => SbtConfiguration, _}
 
 import scala.reflect.ClassTag
 import scala.util.{Failure, Success, Try}
@@ -35,17 +35,19 @@ class ProjectExtractor(
   scalaOrganization: String,
   scalaInstance: Option[ScalaInstance],
   scalaCompilerBridgeBinaryJar: Option[File],
-  scalacOptions: Seq[String],
+  scalacOptions: Map[Configuration, Seq[String]],
   javaHome: Option[File],
-  javacOptions: Seq[String],
+  javacOptions: Map[Configuration, Seq[String]],
   compileOrder: CompileOrder,
   sourceConfigurations: Seq[sbt.Configuration],
   testConfigurations: Seq[sbt.Configuration],
   dependencies: DependencyData,
   play2: Option[Play2Data],
   settingData: Seq[SettingData],
   taskData: Seq[TaskData],
-  commandData: Seq[CommandData]
+  commandData: Seq[CommandData],
+  mainSourceDirectories: Seq[File],
+  testSourceDirectories: Seq[File]
 ) {
 
   private[extractors] def extract: ProjectData = {
@@ -78,7 +80,9 @@ class ProjectExtractor(
       play2,
       settingData,
       taskData,
-      commandData
+      commandData,
+      testSourceDirectories,
+      mainSourceDirectories
     )
   }
 
@@ -253,6 +257,11 @@ object ProjectExtractor extends SbtStateOps with TaskOps {
                                                 state: State) =
     key.in(projectRef, Compile).get(state)
 
+  private def taskInConfig[T](key: TaskKey[T], config: SbtConfiguration)
+    (implicit projectRef: ProjectRef, state: State) =
+    key.in(projectRef, config).get(state)
+
+
   def taskDef: Initialize[Task[ProjectData]] = Def.taskDyn {
 
     implicit val state: State = Keys.state.value
@@ -306,10 +315,16 @@ object ProjectExtractor extends SbtStateOps with TaskOps {
         taskInCompile(Keys.scalaInstance).onlyIf(options.download).value
       val scalaCompilerBridgeBinaryJar =
         keysAdapterEx.myScalaCompilerBridgeBinaryJar.value
-      val scalacOptions =
-        taskInCompile(Keys.scalacOptions).onlyIf(options.download).value
-      val javacOptions =
-        taskInCompile(Keys.javacOptions).onlyIf(options.download).value
+
+      val configurationToScalacOptions = Map(
+        Configuration.Compile -> taskInConfig(Keys.scalacOptions, Compile).onlyIf(options.download).value.getOrElse(Seq.empty),
+        Configuration.Test -> taskInConfig(Keys.scalacOptions, Test).onlyIf(options.download).value.getOrElse(Seq.empty)
+      )
+      val configurationToJavacOptions = Map(
+        Configuration.Compile -> taskInConfig(Keys.javacOptions, Compile).onlyIf(options.download).value.getOrElse(Seq.empty),
+        Configuration.Test -> taskInConfig(Keys.javacOptions, Test).onlyIf(options.download).value.getOrElse(Seq.empty)
+      )
+
 
       val name = Keys.name.in(projectRef, Compile).value
       val organization = Keys.organization.in(projectRef, Compile).value
@@ -319,6 +334,18 @@ object ProjectExtractor extends SbtStateOps with TaskOps {
       val javaHome = Keys.javaHome.in(projectRef, Compile).value
       val compileOrder = Keys.compileOrder.in(projectRef, Compile).value
 
+      val sourceConfigurations = StructureKeys.sourceConfigurations.value
+      val testConfigurations = StructureKeys.testConfigurations.value
+
+      // note: because we are extracting ConfigurationData with all sourceConfigurations and testConfigurations we also have to take sourceDirectories
+      // in all configurations
+      val mainSourceDirectories = Keys.sourceDirectory.in(projectRef)
+        .forAllConfigurations(state, sourceConfigurations)
+        .map(_._2)
+      val testSourceDirectories = Keys.sourceDirectory.in(projectRef)
+        .forAllConfigurations(state, testConfigurations)
+        .map(_._2)
+
       new ProjectExtractor(
         projectRef,
         name,
@@ -339,17 +366,19 @@ object ProjectExtractor extends SbtStateOps with TaskOps {
         scalaOrganization,
         scalaInstance,
         scalaCompilerBridgeBinaryJar,
-        scalacOptions.getOrElse(Seq.empty),
+        configurationToScalacOptions,
         javaHome,
-        javacOptions.getOrElse(Seq.empty),
+        configurationToJavacOptions,
         compileOrder,
         StructureKeys.sourceConfigurations.value,
         StructureKeys.testConfigurations.value,
         StructureKeys.extractDependencies.value,
         StructureKeys.extractPlay2.value,
         StructureKeys.settingData.value,
         StructureKeys.taskData.value,
-        StructureKeys.commandData.value.distinct
+        StructureKeys.commandData.value.distinct,
+        mainSourceDirectories,
+        testSourceDirectories
       ).extract
     }
   }

extractor/src/main/scala/org/jetbrains/sbt/extractors/UtilityTasks.scala

@@ -140,9 +140,12 @@ object UtilityTasks extends SbtStateOps {
       val transitiveTest = cs.filter(c =>
         transitiveExtends(c.extendsConfigs)
           .toSet
-          .intersect(predefinedTest).nonEmpty) ++
-        predefinedTest
-      transitiveTest.distinct
+          .intersect(predefinedTest).nonEmpty
+      )
+      // note: IntegrationTest is not a predefined configuration in each sbt project. It has to be manually enabled.
+      // So returning it from testConfigurations is not necessary and it causes incorrect values to be returned from the sourceDirectory key.
+      val predefinedAvailableTest = predefinedTest.filter(cs.contains).toSeq
+      (predefinedAvailableTest ++ transitiveTest).distinct
     }
 
   def sourceConfigurations: Def.Initialize[Seq[Configuration]] = Def.setting {

extractor/src/main/scala/org/jetbrains/sbt/operations.scala

@@ -25,6 +25,10 @@ trait SbtStateOps {
     def forAllProjects(state: State, projects: Seq[ProjectRef]): Seq[(ProjectRef, T)] =
       projects.flatMap(p => key.in(p).find(state).map(it => (p, it)))
 
+    def forAllConfigurations(state: State, configurations: Seq[sbt.Configuration]): Seq[(sbt.Configuration, T)] = {
+      configurations.flatMap(c => key.in(c).get(structure(state).data).map(it => (c, it)))
+    }
+
   }
 
   implicit class `enrich TaskKey`[T](key: TaskKey[T]) {

shared/src/main/scala/org/jetbrains/sbt/structure/data.scala

@@ -42,26 +42,29 @@ case class StructureData(sbtVersion: String,
  * @param basePackages List of packages to use as base prefixes in chaining
  * @param target Compiler output directory (value of `target` key)
  */
-case class ProjectData(id: String,
-                       buildURI: URI,
-                       name: String,
-                       organization: String,
-                       version: String,
-                       base: File,
-                       packagePrefix: Option[String],
-                       basePackages: Seq[String],
-                       target: File,
-                       configurations: Seq[ConfigurationData],
-                       java: Option[JavaData],
-                       scala: Option[ScalaData],
-                       compileOrder: String,
-                       dependencies: DependencyData,
-                       resolvers: Set[ResolverData],
-                       play2: Option[Play2Data],
-                       settings: Seq[SettingData],
-                       tasks: Seq[TaskData],
-                       commands: Seq[CommandData]
-                      )
+case class ProjectData(
+  id: String,
+  buildURI: URI,
+  name: String,
+  organization: String,
+  version: String,
+  base: File,
+  packagePrefix: Option[String],
+  basePackages: Seq[String],
+  target: File,
+  configurations: Seq[ConfigurationData],
+  java: Option[JavaData],
+  scala: Option[ScalaData],
+  compileOrder: String,
+  dependencies: DependencyData,
+  resolvers: Set[ResolverData],
+  play2: Option[Play2Data],
+  settings: Seq[SettingData],
+  tasks: Seq[TaskData],
+  commands: Seq[CommandData],
+  testSourceDirectories: Seq[File],
+  mainSourceDirectories: Seq[File]
+)
 
 case class SettingData(label: String, description: Option[String], rank: Int, stringValue: Option[String])
 case class TaskData(label: String, description: Option[String], rank: Int)
@@ -108,7 +111,7 @@ case class ConfigurationData(id: String,
 
 case class DirectoryData(file: File, managed: Boolean)
 
-case class JavaData(home: Option[File], options: Seq[String])
+case class JavaData(home: Option[File], options: Map[Configuration, Seq[String]])
 
 /**
  * Analog of `sbt.internal.inc.ScalaInstance`
@@ -126,15 +129,22 @@ case class ScalaData(
   compilerJars: Seq[File],
   extraJars: Seq[File],
   compilerBridgeBinaryJar: Option[File],
-  options: Seq[String]
+  options: Map[Configuration, Seq[String]]
 ) {
   def allJars: Seq[File] = libraryJars ++ compilerJars ++ extraJars
   def allCompilerJars: Seq[File] = libraryJars ++ compilerJars
 }
 
-case class DependencyData(projects: Seq[ProjectDependencyData],
-                          modules: Seq[ModuleDependencyData],
-                          jars: Seq[JarDependencyData])
+case class DependencyData(projects: Dependencies[ProjectDependencyData],
+                          modules: Dependencies[ModuleDependencyData],
+                          jars: Dependencies[JarDependencyData])
+
+/**
+ * When the project is imported without prod/test sources feature enabled, all dependencies are put in forProduction parameter.
+ * @param forTest dependencies that should go to the test module
+ * @param forProduction dependencies that should go to the main module
+ */
+case class Dependencies[T](forTest: Seq[T], forProduction: Seq[T])
 
 /**
  * Inter-project dependency