def classDirectory()

in extractor/src/main/scala/org/jetbrains/sbt/extractors/ProjectExtractor.scala [362:500]
118 lines of code
6 McCabe index (conditional complexity)

    def classDirectory(conf: sbt.Configuration) =
      (projectRef / conf / Keys.classDirectory).find(state)

    val excludedDirectories =
      (projectRef / SettingKeys.ideExcludedDirectories)
        .find(state)
        .orElse(
          (projectRef / SettingKeys.sbtIdeaExcludeFolders)
            .find(state)
            .map(_.map(file))
        )
        .getOrElse(Seq.empty)

    def ideOutputDirectory(conf: sbt.Configuration) =
      (projectRef / conf / SettingKeys.ideOutputDirectory).find(state).flatten

    val options = StructureKeys.sbtStructureOpts.value

    val managedSourceDirsInConfig =
      settingInConfiguration(Keys.managedSourceDirectories)
    val unmanagedSourceDirsInConfig =
      settingInConfiguration(Keys.unmanagedSourceDirectories)
    val managedResourceDirsInConfig =
      settingInConfiguration(Keys.managedResourceDirectories)
    val unmanagedResourceDirsInConfig =
      settingInConfiguration(Keys.unmanagedResourceDirectories)

    Def.taskDyn {
      val scalaOrganization =
        (projectRef / Compile / Keys.scalaOrganization).value
      val scalaInstanceResult: Result[Option[ScalaInstance]] =
        taskInCompile(Keys.scalaInstance).onlyIf(options.download).result.value

      // In some peculiar setups there might be no scala instance configured (for example in Scala 3 repository)
      // In this case we still shouldn't fail the import process
      val scalaInstance: Option[ScalaInstance] =
        scalaInstanceResult.toEither.toOption.flatten

      val scalaCompilerBridgeBinaryJar =
        PluginCompat.myScalaCompilerBridgeBinaryJar.value

      def mapToCompilerOptions(configToOptions: Seq[(Configuration, Seq[String])]) = {
        configToOptions.collect { case(config, options) if options.nonEmpty =>
          CompilerOptions(config, options)
        }
      }

      val scalacOptions = mapToCompilerOptions(
        Seq(
          (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 javacOptions = mapToCompilerOptions(
        Seq(
          (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 = (projectRef / Compile / Keys.name).value
      val organization = (projectRef / Compile / Keys.organization).value
      val version = (projectRef / Compile / Keys.version).value
      val base = (projectRef / Compile / Keys.baseDirectory).value
      val target = (projectRef / Compile / Keys.target).value
      val javaHome = (projectRef / Compile / Keys.javaHome).value
      val compileOrder = (projectRef / Compile / Keys.compileOrder).value

      val sourceConfigurations = StructureKeys.sourceConfigurations.value
      val testConfigurations = StructureKeys.testConfigurations.value

      val mainSourceDirectories = (projectRef / Keys.sourceDirectory)
        .forAllConfigurations(state, sourceConfigurations)
        .map(_._2).distinct
      val testSourceDirectories = (projectRef / Keys.sourceDirectory)
        .forAllConfigurations(state, testConfigurations)
        .map(_._2).distinct

      val resolvedProject = Keys.thisProject.value

      val projectData = new ProjectExtractor(
        projectRef,
        resolvedProject,
        name,
        organization,
        version,
        base,
        target,
        idePackagePrefix,
        basePackages,
        Keys.fullResolvers.value,
        classDirectory,
        managedSourceDirsInConfig,
        unmanagedSourceDirsInConfig,
        managedResourceDirsInConfig,
        unmanagedResourceDirsInConfig,
        excludedDirectories,
        ideOutputDirectory,
        scalaOrganization,
        scalaInstance,
        scalaCompilerBridgeBinaryJar,
        scalacOptions,
        javaHome,
        javacOptions,
        compileOrder,
        StructureKeys.sourceConfigurations.value,
        StructureKeys.testConfigurations.value,
        StructureKeys.extractDependencies.value,
        StructureKeys.extractPlay2.value,
        StructureKeys.settingData.value,
        StructureKeys.taskData.value,
        StructureKeys.commandData.value.distinct,
        mainSourceDirectories,
        testSourceDirectories,
        options.separateProdAndTestSources
      ).extract

      val runGeneratedManagedSourcesTask = StructureKeys.generateManagedSourcesDuringStructureDump.value
      if (runGeneratedManagedSourcesTask) {
        Def.task {
          val log = Keys.streams.value.log
          // Need to use `.toEither` because Result, Inc and Value are top level definitions in
          // sbt 1/Scala 2 and an enum in sbt 2/Scala 3 (Inc and Value are defined inside the Result companion object),
          // and are therefore not source compatible.
          val managedSources = generateManagedSourcesTaskDef.result.value.toEither match {
            case Left(cause) =>
              log.warn(s"Generating managed sources failed in $name. Continuing with the project import. The stack trace of the failure is printed below:")
              val trace = stackTraceAsString(cause)
              log.warn(trace)
              Seq.empty
            case Right(sources) => sources
          }
          projectData.copy(generatedManagedSources = managedSources.nonEmpty)
        }
      } else {
        Def.task(projectData)
      }
    }