fun main()

in intellij-plugin-verifier/verifier-cli/src/main/java/com/jetbrains/pluginverifier/PluginVerifierMain.kt [94:160]
58 lines of code
2 McCabe index (conditional complexity)

  fun main(args: Array<String>) {
    println("Starting the IntelliJ Plugin Verifier $pluginVerifierVersion")
    val opts = CmdOpts()
    var freeArgs = Args.parse(opts, args, false)

    if (freeArgs.isEmpty()) {
      System.err.println(
        "The command is not specified. Should be one of: " + commandRunners.joinToString { "'" + it.commandName + "'" }
      )
      Args.usage(System.err, CmdOpts())

      exitProcess(1)
    }

    val command = freeArgs[0]
    freeArgs = freeArgs.drop(1)

    val runner = findTaskRunner(command)
    val outputOptions = OptionsParser.parseOutputOptions(opts)

    val pluginsExtractDirectory = getPluginsExtractDirectory()
    val pluginDownloadDirDiskSpaceSetting = getDiskSpaceSetting("plugin.verifier.cache.dir.max.space", 5L * 1024)

    PluginArchiveManager(pluginsExtractDirectory).use { pluginArchiveManager ->
      val pluginRepository =
        when (val repositoryProvision = LocalPluginRepositoryProvider.getLocalPluginRepository(opts, downloadDirectory, pluginArchiveManager)) {
          is Provided -> repositoryProvision.pluginRepository
          Unavailable -> MarketplaceRepository(URL(pluginRepositoryUrl))
        }

      val pluginFilesBank = PluginFilesBank.create(pluginRepository, downloadDirectory, pluginDownloadDirDiskSpaceSetting)

      DefaultPluginDetailsProvider(pluginArchiveManager).use { pluginDetailsProvider ->
        val reportageAggregator = LoggingPluginVerificationReportageAggregator()
        DirectoryBasedPluginVerificationReportage(reportageAggregator) { outputOptions.getTargetReportDirectory(it) }.use { reportage ->
          measurePluginVerification {
            val detailsCacheSize = System.getProperty("plugin.verifier.plugin.details.cache.size")?.toIntOrNull() ?: 32
            val taskResult = SizeLimitedPluginDetailsCache(
              detailsCacheSize,
              pluginFilesBank,
              pluginDetailsProvider
            ).use { pluginDetailsCache ->
              runner.getParametersBuilder(
                pluginRepository,
                pluginDetailsCache,
                pluginArchiveManager,
                reportage
              ).build(opts, freeArgs).use { parameters ->
                reportage.logVerificationStage("Task ${runner.commandName} parameters:\n${parameters.presentableText}")

                parameters
                  .createTask()
                  .execute(reportage, pluginDetailsCache)
              }
            }
            taskResult
          }.run {
            val taskResultsPrinter = taskResult.createTaskResultsPrinter(pluginRepository)
            taskResultsPrinter.printResults(taskResult, outputOptions)
            reportage.reportDownloadStatistics(outputOptions, pluginFilesBank)
            reportageAggregator.handleAggregatedReportage()
            reportage.reportVerificationDuration(this)
          }
        }
      }
    }
  }