fun validate()

in intellij-plugin-structure/structure-fleet/src/main/kotlin/com/jetbrains/plugin/structure/fleet/FleetPluginDescriptor.kt [32:174]
128 lines of code
9 McCabe index (conditional complexity)

  fun validate(): List<PluginProblem> {
    val problems = mutableListOf<PluginProblem>()
    when {
      id.isNullOrBlank() -> {
        problems.add(PropertyNotSpecified(FleetDescriptorSpec.ID_FIELD_NAME))
      }

      !ID_REGEX.matches(id) -> {
        problems.add(InvalidPluginIDProblem(id))
      }
    }

    if (version.isNullOrBlank()) {
      problems.add(PropertyNotSpecified(FleetDescriptorSpec.VERSION_FIELD_NAME))
    }

    val metaSpec = FleetDescriptorSpec.Meta
    if (meta?.description.isNullOrBlank()) {
      problems.add(PropertyNotSpecified(metaSpec.relativeFieldPath(metaSpec.DESCRIPTION_FIELD_NAME)))
    }

    if (meta?.vendor.isNullOrBlank()) {
      problems.add(PropertyNotSpecified(metaSpec.relativeFieldPath(metaSpec.VENDOR_FIELD_NAME)))
    }

    val supportedProducts = meta?.getSupportedProductCodes() ?: emptySet()
    val products = supportedProducts.mapNotNull { FleetProduct.fromProductCode(it) }.toSet()

    if (products.size != supportedProducts.size) {
      problems.add(
        InvalidSupportedProductsListProblem(
          constraint = "must contain only product codes from ${
            FleetProduct.values().map { it.productCode }
          }, got: $supportedProducts"
        )
      )
    }
    val (isLegacyVersioning, isUnifiedVersioning) = products.partition { it.legacyVersioning }
      .let { (legacy, unified) ->
        Pair(legacy.isNotEmpty(), unified.isNotEmpty())
      }
    if (isLegacyVersioning && isUnifiedVersioning) {
      problems.add(
        InvalidSupportedProductsListProblem(
          constraint = "must contain either only legacy or only unified versioning products"
        )
      )
    }

    val shipVersionSpec = FleetDescriptorSpec.CompatibleShipVersion
    if (id != SHIP_PLUGIN_ID) {
      when {
        compatibleShipVersionRange == null -> {
          problems.add(PropertyNotSpecified(shipVersionSpec.NAME))
        }

        compatibleShipVersionRange.from.isNullOrBlank() -> {
          problems.add(PropertyNotSpecified(shipVersionSpec.relativeFieldPath(shipVersionSpec.FROM_FIELD_NAME)))
        }

        compatibleShipVersionRange.to.isNullOrBlank() -> {
          problems.add(PropertyNotSpecified(shipVersionSpec.relativeFieldPath(shipVersionSpec.TO_FIELD_NAME)))
        }

        else -> {
          val fromSemver = parseVersionOrNull(compatibleShipVersionRange.from)
          val toSemver = parseVersionOrNull(compatibleShipVersionRange.to)
          when {
            fromSemver == null -> {
              problems.add(
                InvalidSemverFormat(
                  descriptorPath = FleetDescriptorSpec.DESCRIPTOR_FILE_NAME,
                  versionName = shipVersionSpec.relativeFieldPath(shipVersionSpec.FROM_FIELD_NAME),
                  version = compatibleShipVersionRange.from
                )
              )
            }

            toSemver == null -> {
              problems.add(
                InvalidSemverFormat(
                  descriptorPath = FleetDescriptorSpec.DESCRIPTOR_FILE_NAME,
                  versionName = shipVersionSpec.relativeFieldPath(shipVersionSpec.TO_FIELD_NAME),
                  version = compatibleShipVersionRange.to
                )
              )
            }

            fromSemver.isGreaterThan(toSemver) -> {
              problems.add(
                InvalidVersionRange(
                  descriptorPath = FleetDescriptorSpec.DESCRIPTOR_FILE_NAME,
                  since = compatibleShipVersionRange.from,
                  until = compatibleShipVersionRange.to
                )
              )
            }

            else -> {
              val fromVersionProblems = validateVersion(
                fieldName = shipVersionSpec.relativeFieldPath(shipVersionSpec.FROM_FIELD_NAME),
                semver = fromSemver,
                isLegacy = isLegacyVersioning
              )
              problems.addAll(fromVersionProblems)
              if (fromVersionProblems.isEmpty()) {
                problems.addAll(
                  validateVersion(
                    fieldName = shipVersionSpec.relativeFieldPath(shipVersionSpec.TO_FIELD_NAME),
                    semver = toSemver,
                    isLegacy = isLegacyVersioning
                  )
                )
              }
            }
          }
        }
      }
    }

    val readableName = meta?.name
    when {
      readableName.isNullOrBlank() -> {
        problems.add(PropertyNotSpecified(metaSpec.relativeFieldPath(metaSpec.NAME_FIELD_NAME)))
      }

      else -> {
        validatePropertyLength(
          descriptor = FleetDescriptorSpec.DESCRIPTOR_FILE_NAME,
          propertyName = metaSpec.relativeFieldPath(metaSpec.NAME_FIELD_NAME),
          propertyValue = readableName,
          maxLength = MAX_NAME_LENGTH,
          problems = problems
        )
        validatePluginNameIsCorrect(
          descriptor = FleetDescriptorSpec.DESCRIPTOR_FILE_NAME,
          name = readableName,
          problems = problems
        )
      }
    }
    return problems
  }