public static CompatibilityResult GetCompatibilityResult(PackageDetailsWithApiIndices package, string apiMethodSignature, string version, string target = DEFAULT_TARGET, bool checkLesserPackage = false)
{
var compatiblityResult = new CompatibilityResult
{
Compatibility = Compatibility.UNKNOWN,
CompatibleVersions = new List <string>()
};
if (package == null || apiMethodSignature == null || !NuGetVersion.TryParse(version, out var targetversion))
{
return(compatiblityResult);
}
if (package.PackageDetails.IsDeprecated)
{
compatiblityResult.Compatibility = Compatibility.DEPRECATED;
return(compatiblityResult);
}
var foundApi = GetApiDetails(package, apiMethodSignature);
if (foundApi == null)
{
if (!checkLesserPackage || package.PackageDetails.Targets == null || !package.PackageDetails.Targets.TryGetValue(target, out var targetFramework))
{
compatiblityResult.Compatibility = Compatibility.INCOMPATIBLE;
return(compatiblityResult);
}
compatiblityResult.Compatibility = hasLesserTarget(version, targetFramework.ToArray()) ? Compatibility.COMPATIBLE : Compatibility.INCOMPATIBLE;
compatiblityResult.CompatibleVersions = targetFramework.ToArray()
.Where(v =>
{
if (!NuGetVersion.TryParse(v, out var semversion))
{
return(false);
}
return(semversion.CompareTo(targetversion) > 0);
}).ToList();
return(compatiblityResult);
}
if (!foundApi.Targets.TryGetValue(target, out var framework))
{
compatiblityResult.Compatibility = Compatibility.INCOMPATIBLE;
return(compatiblityResult);
}
compatiblityResult.Compatibility = hasLesserTarget(version, framework.ToArray()) ? Compatibility.COMPATIBLE : Compatibility.INCOMPATIBLE;
compatiblityResult.CompatibleVersions = framework.ToArray()
.Where(v =>
{
if (!NuGetVersion.TryParse(v, out var semversion))
{
return(false);
}
return(semversion.CompareTo(targetversion) > 0);
}).ToList();
return(compatiblityResult);
}
private static IEnumerable <string> GetCompatiblePackageVersionsForTarget(
ApiDetails apiDetails,
PackageDetailsWithApiIndices package,
string target,
bool checkLesserPackage)
{
// If ApiDetails found, use them to get compatible versions
if (apiDetails == null)
{
if (!checkLesserPackage ||
package.PackageDetails.Targets == null ||
!package.PackageDetails.Targets.TryGetValue(target, out var compatiblePackageVersionsForTarget))
{
return(new List <string>());
}
return(compatiblePackageVersionsForTarget.ToList());
}
// If ApiDetails not found, fallback to using PackageDetails to get compatible versions
else if (apiDetails.Targets.TryGetValue(target, out var compatiblePackageVersionsForTarget))
{
return(compatiblePackageVersionsForTarget.ToList());
}
return(new List <string>());
}
public static CompatibilityResult GetCompatibilityResult(
PackageDetailsWithApiIndices package,
string apiMethodSignature,
string packageVersion,
string target = "net6.0",
bool checkLesserPackage = false)
{
var compatibilityResult = new CompatibilityResult
{
Compatibility = Compatibility.UNKNOWN,
CompatibleVersions = new List <string>()
};
// If necessary data to determine compatibility is missing, return unknown compatibility
if (package == null ||
apiMethodSignature == null ||
!NuGetVersion.TryParse(packageVersion, out var validPackageVersion))
{
return(compatibilityResult);
}
if (package.PackageDetails.IsDeprecated)
{
compatibilityResult.Compatibility = Compatibility.DEPRECATED;
return(compatibilityResult);
}
var apiDetails = GetApiDetails(package, apiMethodSignature);
var compatiblePackageVersionsForTarget =
GetCompatiblePackageVersionsForTarget(apiDetails, package, target, checkLesserPackage);
// If package version is greater than the greatest compatible version, it is likely this latest version
// has not been assessed and added to the compatibility datastore. If it has a lower version of the same
// major that is compatible, then it will be marked as Compatible. It will be marked as Incompatible otherwise
var maxCompatibleVersion = NugetVersionHelper.GetMaxVersion(compatiblePackageVersionsForTarget);
if (maxCompatibleVersion != null &&
!maxCompatibleVersion.IsZeroVersion() &&
validPackageVersion.IsGreaterThan(maxCompatibleVersion))
{
compatibilityResult.Compatibility = validPackageVersion.HasSameMajorAs(maxCompatibleVersion)
? Compatibility.COMPATIBLE
: Compatibility.INCOMPATIBLE;
}
// In all other cases, just check to see if the list of compatible versions for the target framework
// contains the current package version
else
{
compatibilityResult.Compatibility = validPackageVersion.HasLowerOrEqualCompatibleVersion(compatiblePackageVersionsForTarget)
? Compatibility.COMPATIBLE
: Compatibility.INCOMPATIBLE;
}
// CompatibleVersions are recommended as potential upgrades from current version
compatibilityResult.CompatibleVersions = validPackageVersion.FindGreaterCompatibleVersions(compatiblePackageVersionsForTarget).ToList();
return(compatibilityResult);
}
public static CompatibilityResult GetCompatibilityResult(PackageDetailsWithApiIndices package, CodeEntityDetails codeEntityDetails, string target = "net6.0", bool checkLesserPackage = false)
{
//If invocation, we will try to find it in a later package
if (codeEntityDetails.CodeEntityType == CodeEntityType.Method)
{
if (string.IsNullOrEmpty(codeEntityDetails.Namespace))
{
// codelyzer was not able to parse the symbol from the semantic model, so we can't accurately assess the compatibility.
return(new CompatibilityResult
{
Compatibility = Compatibility.UNKNOWN,
CompatibleVersions = new List <string>()
});
}
return(GetCompatibilityResult(package, codeEntityDetails.OriginalDefinition, codeEntityDetails.Package.Version, target, checkLesserPackage));
}
//If another node type, we will not try to find it. Compatibility will be based on the package compatibility
else
{
var compatibilityResult = new CompatibilityResult
{
Compatibility = Compatibility.UNKNOWN,
CompatibleVersions = new List <string>()
};
if (package == null || !NuGetVersion.TryParse(codeEntityDetails.Package.Version, out var targetversion))
{
return(compatibilityResult);
}
if (package.PackageDetails.IsDeprecated)
{
compatibilityResult.Compatibility = Compatibility.DEPRECATED;
return(compatibilityResult);
}
//For other code entities, we just need to check if the package has a compatible target:
if (package.PackageDetails.Targets.ContainsKey(target))
{
compatibilityResult.Compatibility = Compatibility.COMPATIBLE;
return(compatibilityResult);
}
else
{
compatibilityResult.Compatibility = Compatibility.INCOMPATIBLE;
}
return(compatibilityResult);
}
}
private static ApiDetails GetApiDetails(PackageDetailsWithApiIndices packageDetailsWithApiIndices, string apiMethodSignature)
{
if (packageDetailsWithApiIndices == null ||
packageDetailsWithApiIndices.PackageDetails == null ||
packageDetailsWithApiIndices.IndexDict == null ||
packageDetailsWithApiIndices.PackageDetails.Api == null ||
apiMethodSignature == null)
{
return(null);
}
var index = packageDetailsWithApiIndices.IndexDict.GetValueOrDefault(apiMethodSignature.Replace("?", ""), -1);
if (index >= 0 && index < packageDetailsWithApiIndices.PackageDetails.Api.Count())
{
return(packageDetailsWithApiIndices.PackageDetails.Api[index]);
}
return(null);
}
