String toString()

in lib/src/solver/incompatibility.dart [99:211]

• 100 lines of code
• 24 McCabe index (conditional complexity)

  String toString([Map<String, PackageDetail>? details]) {
    if (cause == IncompatibilityCause.dependency) {
      assert(terms.length == 2);

      var depender = terms.first;
      var dependee = terms.last;
      assert(depender.isPositive);
      assert(!dependee.isPositive);

      return '${_terse(depender, details, allowEvery: true)} depends on '
          '${_terse(dependee, details)}';
    } else if (cause == IncompatibilityCause.useLatest) {
      assert(terms.length == 1);

      var forbidden = terms.last;
      assert(forbidden.isPositive);

      return 'the latest version of ${_terseRef(forbidden, details)} '
          '(${VersionConstraint.any.difference(forbidden.constraint)}) '
          'is required';
    } else if (cause is SdkCause) {
      assert(terms.length == 1);
      assert(terms.first.isPositive);

      var cause = this.cause as SdkCause;
      var buffer = StringBuffer(
          '${_terse(terms.first, details, allowEvery: true)} requires ');
      if (!cause.sdk.isAvailable) {
        buffer.write('the ${cause.sdk.name} SDK');
      } else {
        if (cause.sdk.name != 'Dart') buffer.write(cause.sdk.name + ' ');
        buffer.write('SDK version ${cause.constraint}');
      }
      return buffer.toString();
    } else if (cause == IncompatibilityCause.noVersions) {
      assert(terms.length == 1);
      assert(terms.first.isPositive);
      return 'no versions of ${_terseRef(terms.first, details)} '
          'match ${terms.first.constraint}';
    } else if (cause is PackageNotFoundCause) {
      assert(terms.length == 1);
      assert(terms.first.isPositive);

      var cause = this.cause as PackageNotFoundCause;
      return "${_terseRef(terms.first, details)} doesn't exist "
          '(${cause.exception.message})';
    } else if (cause == IncompatibilityCause.unknownSource) {
      assert(terms.length == 1);
      assert(terms.first.isPositive);
      return '${terms.first.package.name} comes from unknown source '
          '"${terms.first.package.source}"';
    } else if (cause == IncompatibilityCause.root) {
      // [IncompatibilityCause.root] is only used when a package depends on the
      // entrypoint with an incompatible version, so we want to print the
      // entrypoint's actual version to make it clear why this failed.
      assert(terms.length == 1);
      assert(!terms.first.isPositive);
      assert(terms.first.package.isRoot);
      return '${terms.first.package.name} is ${terms.first.constraint}';
    } else if (isFailure) {
      return 'version solving failed';
    }

    if (terms.length == 1) {
      var term = terms.single;
      if (term.constraint.isAny) {
        return '${_terseRef(term, details)} is '
            "${term.isPositive ? 'forbidden' : 'required'}";
      } else {
        return '${_terse(term, details)} is '
            "${term.isPositive ? 'forbidden' : 'required'}";
      }
    }

    if (terms.length == 2) {
      var term1 = terms.first;
      var term2 = terms.last;
      if (term1.isPositive == term2.isPositive) {
        if (term1.isPositive) {
          var package1 = term1.constraint.isAny
              ? _terseRef(term1, details)
              : _terse(term1, details);
          var package2 = term2.constraint.isAny
              ? _terseRef(term2, details)
              : _terse(term2, details);
          return '$package1 is incompatible with $package2';
        } else {
          return 'either ${_terse(term1, details)} or '
              '${_terse(term2, details)}';
        }
      }
    }

    var positive = <String>[];
    var negative = <String>[];
    for (var term in terms) {
      (term.isPositive ? positive : negative).add(_terse(term, details));
    }

    if (positive.isNotEmpty && negative.isNotEmpty) {
      if (positive.length == 1) {
        var positiveTerm = terms.firstWhere((term) => term.isPositive);
        return '${_terse(positiveTerm, details, allowEvery: true)} requires '
            "${negative.join(' or ')}";
      } else {
        return "if ${positive.join(' and ')} then ${negative.join(' or ')}";
      }
    } else if (positive.isNotEmpty) {
      return "one of ${positive.join(' or ')} must be false";
    } else {
      return "one of ${negative.join(' or ')} must be true";
    }
  }