fun generateAspectsFromTemplates()

in server/server/src/main/kotlin/org/jetbrains/bazel/server/bsp/managers/BazelBspAspectsManager.kt [113:188]
67 lines of code
1 McCabe index (conditional complexity)

  fun generateAspectsFromTemplates(
    rulesetLanguages: List<RulesetLanguage>,
    externalRulesetNames: List<String>,
    workspaceContext: WorkspaceContext,
    toolchains: Map<RulesetLanguage, String?>,
    bazelRelease: BazelRelease,
    repoMapping: RepoMapping,
    featureFlags: FeatureFlags,
    bazelInfo: BazelInfo,
  ) {
    detectBazelIgnoreAndErrorOut(bazelInfo)

    val languageRuleMap = rulesetLanguages.associateBy { it.language }
    val activeLanguages = rulesetLanguages.map { it.language }.toSet()
    val kotlinEnabled = Language.Kotlin in activeLanguages
    val javaEnabled = Language.Java in activeLanguages
    val pythonEnabled = Language.Python in activeLanguages
    val bazel8OrAbove = bazelRelease.major >= 8
    Language.entries.filter { it.isTemplate }.forEach {
      val ruleLanguage = languageRuleMap[it]

      val outputFile = aspectsPath.resolve(it.toAspectRelativePath())
      val templateFilePath = it.toAspectTemplateRelativePath()
      val canonicalRuleName = ruleLanguage?.calculateCanonicalName(repoMapping).orEmpty()
      val apparentRuleName = ruleLanguage?.rulesetName.orEmpty()
      val protobufRepoName = ProtobufRepoMappings(repoMapping).getMappedProtobufRepoName(canonicalRuleName, apparentRuleName)
      val variableMap =
        mapOf(
          "rulesetName" to canonicalRuleName,
          "rulesetNameApparent" to apparentRuleName,
          "kotlinEnabled" to kotlinEnabled.toString(),
          "javaEnabled" to javaEnabled.toString(),
          "pythonEnabled" to pythonEnabled.toString(),
          // https://github.com/JetBrains/intellij-community/tree/master/build/jvm-rules
          "usesRulesJvm" to ("rules_jvm" in externalRulesetNames).toString(),
          "bazel8OrAbove" to bazel8OrAbove.toString(),
          "toolchainType" to ruleLanguage?.let { rl -> toolchains[rl] },
          "codeGeneratorRules" to workspaceContext.pythonCodeGeneratorRuleNames.toStarlarkString(),
          "protobufRepoName" to protobufRepoName.orEmpty(),
          "bspPath" to Constants.DOT_BAZELBSP_DIR_NAME,
      )
      templateWriter.writeToFile(templateFilePath, outputFile, variableMap)
    }

    templateWriter.writeToFile(
      Constants.CORE_BZL + Constants.TEMPLATE_EXTENSION,
      aspectsPath.resolve(Constants.CORE_BZL),
      mapOf(
        "isPropagateExportsFromDepsEnabled" to
          featureFlags.isPropagateExportsFromDepsEnabled.toStarlarkString(),
        "bspPath" to Constants.DOT_BAZELBSP_DIR_NAME,
      ),
    )

    // https://bazel.build/rules/lib/builtins/Label#repo_name
    // The canonical name of the repository containing the target referred to by this label, without any leading at-signs (@).
    val starlarkRepoMapping =
      when (repoMapping) {
        is BzlmodRepoMapping -> {
          repoMapping.canonicalRepoNameToLocalPath
            .map { (key, value) ->
              "\"${key.dropWhile { it == '@' }}\": \"${value.invariantSeparatorsPathString}\""
            }.joinToString(",\n", "{\n", "\n}")
        }

        is RepoMappingDisabled -> "{}"
      }

    templateWriter.writeToFile(
      "utils/utils.bzl" + Constants.TEMPLATE_EXTENSION,
      aspectsPath.resolve("utils").resolve("utils.bzl"),
      mapOf(
        "repoMapping" to starlarkRepoMapping,
      ),
    )
  }