override fun build()

in intellij-plugin-verifier/verifier-cli/src/main/java/com/jetbrains/pluginverifier/tasks/checkPluginApi/CheckPluginApiParamsBuilder.kt [48:107]
48 lines of code
2 McCabe index (conditional complexity)

  override fun build(opts: CmdOpts, freeArgs: List<String>): CheckPluginApiParams {
    val apiOpts = CheckPluginApiOpts()
    val args = Args.parse(apiOpts, freeArgs.toTypedArray(), false)

    if (args.size != 3) {
      Args.usage(apiOpts)
      throw IllegalArgumentException(USAGE)
    }

    val basePluginFile = Paths.get(args[0])
    require(basePluginFile.exists()) { "Base plugin file $basePluginFile doesn't exist" }

    val newPluginFile = Paths.get(args[1])
    require(newPluginFile.exists()) { "New plugin file $newPluginFile doesn't exist" }

    val pluginsToCheckFile = Paths.get(args[2])
    require(pluginsToCheckFile.exists()) { "File with list of plugins' IDs to check doesn't exist: $pluginsToCheckFile" }

    val pluginsSet = parsePluginsToCheck(pluginsToCheckFile)

    val pluginPackageFilter = parsePackageFilter(apiOpts.pluginPackages)

    val jdkPath = requireNotNull(opts.runtimeDir?.let { Paths.get(it) }) { "JDK runtime is not specified" }
    val problemsFilters = OptionsParser.getProblemsFilters(opts)

    val basePluginDetails = providePluginDetails(basePluginFile)
    basePluginDetails.closeOnException {
      val newPluginDetails = providePluginDetails(newPluginFile)
      newPluginDetails.closeOnException {

        val jdkDescriptor = JdkDescriptorCreator.createJdkDescriptor(jdkPath)
        jdkDescriptor.closeOnException {
          val baseClassResolverProvider = PluginApiClassResolverProvider(jdkDescriptor, basePluginDetails, pluginPackageFilter)
          val baseVerificationDescriptors = pluginsSet.pluginsToCheck.map {
            PluginVerificationDescriptor.Plugin(it, basePluginDetails.pluginInfo, baseClassResolverProvider, jdkDescriptor.jdkVersion)
          }

          val newClassResolverProvider = PluginApiClassResolverProvider(jdkDescriptor, newPluginDetails, pluginPackageFilter)
          val newVerificationDescriptors = pluginsSet.pluginsToCheck.map {
            PluginVerificationDescriptor.Plugin(it, newPluginDetails.pluginInfo, newClassResolverProvider, jdkDescriptor.jdkVersion)
          }

          val baseVerificationTarget = PluginVerificationTarget.Plugin(basePluginDetails.pluginInfo, jdkDescriptor.jdkVersion)
          val newVerificationTarget = PluginVerificationTarget.Plugin(newPluginDetails.pluginInfo, jdkDescriptor.jdkVersion)

          return CheckPluginApiParams(
            basePluginDetails,
            newPluginDetails,
            jdkDescriptor,
            problemsFilters,
            baseVerificationDescriptors,
            newVerificationDescriptors,
            baseVerificationTarget,
            newVerificationTarget,
            opts.excludeExternalBuildClassesSelector
          )
        }
      }
    }
  }