private static JetSemanticVersion GetResolvedVersion(string id, Dictionary <string, PackageData> resolvedPackages)
{
if (resolvedPackages.TryGetValue(id, out var packageData) &&
JetSemanticVersion.TryParse(packageData.PackageDetails.Version, out var version))
{
return(version);
}
return(JetSemanticVersion.Empty);
}
private JetSemanticVersion GetMinimumVersion(string id)
{
EditorPackageDetails editorPackageDetails = null;
if (myGlobalManifest?.Packages.TryGetValue(id, out editorPackageDetails) == true &&
JetSemanticVersion.TryParse(editorPackageDetails?.MinimumVersion, out var version))
{
return(version);
}
return(JetSemanticVersion.Empty);
}
private void ProcessPackagesDirectories()
{
try
{
var solutionFolder = mySolution.SolutionDirectory;
var packagesFolder = solutionFolder.Combine("Packages");
var packagesCacheFolder = solutionFolder.Combine("Library").Combine("PackageCache");
var candidates = new[] { packagesFolder, packagesCacheFolder };
foreach (var candidate in candidates)
{
foreach (var folder in candidate.GetDirectoryEntries())
{
if (!folder.IsDirectory)
{
continue;
}
// Cache entries are usually name@version, but git and local tarball packages don't
// have versions, so are name@hash and name@hash-timestamp, respectively. Packages
// in the Packages folder don't usually have a version, but can do, and things will
// still work, so try and find one
var nameAndSuffix = folder.RelativePath.Name.Split('@');
if (nameAndSuffix.Length != 2)
{
continue;
}
var name = nameAndSuffix[0];
var suffix = nameAndSuffix[1];
// If the suffix is a version, use it to pick the latest version. If not, pick an
// arbitrary cache entry. There is no guarantee that either method gets the right
// cache entry, but it's the best we can do without proper package details
if (JetSemanticVersion.TryParse(suffix, out var version) &&
myVersionsFromDirectories.TryGetValue(name, out var oldSuffix) &&
JetSemanticVersion.TryParse(oldSuffix, out var oldVersion) &&
oldVersion > version)
{
continue;
}
myVersionsFromDirectories[name] = suffix;
}
}
}
catch (Exception e)
{
myLogger.Error(e, "Exception during calculating unity shader include paths");
}
}
private List <PackageData> GetPackagesFromDependencies([NotNull] string registry,
[NotNull] FileSystemPath builtInPackagesFolder,
Dictionary <string, PackageData> resolvedPackages,
List <PackageData> packagesToProcess)
{
var dependencies = new Dictionary <string, JetSemanticVersion>();
// Find the highest requested version of each dependency of each package being processed. Check all
// dependencies, even if we've already resolved it, in case we find a higher version
foreach (var packageData in packagesToProcess)
{
foreach (var(id, versionString) in packageData.PackageDetails.Dependencies)
{
// Embedded packages take precedence over any version
if (IsEmbeddedPackage(id, resolvedPackages))
{
continue;
}
if (!JetSemanticVersion.TryParse(versionString, out var dependencyVersion))
{
continue;
}
var currentMaxVersion = GetCurrentMaxVersion(id, dependencies);
var minimumVersion = GetMinimumVersion(id);
dependencies[id] = Max(dependencyVersion, Max(currentMaxVersion, minimumVersion));
}
}
var newPackages = new List <PackageData>();
foreach (var(id, version) in dependencies)
{
if (version > GetResolvedVersion(id, resolvedPackages))
{
newPackages.Add(GetPackageData(id, version.ToString(), registry, builtInPackagesFolder, null));
}
}
return(newPackages);
}
private string GetCacheSuffix(string packageName)
{
// TODO: This cache should be based on resolved packages, like we have in the frontend for PackageManager
// TODO: Invalidate this cache when Packages/manifest.json or Packages/packages-lock.json changes
if (myCacheSuffixes == null)
{
lock (myLockObject)
{
if (myCacheSuffixes == null)
{
var result = new ConcurrentDictionary <string, string>();
try
{
var solutionFolder = mySolution.SolutionDirectory;
var packagesFolder = solutionFolder.Combine("Packages");
var packagesCacheFolder = solutionFolder.Combine("Library").Combine("PackageCache");
var candidates = new[] { packagesFolder, packagesCacheFolder };
foreach (var candidate in candidates)
{
foreach (var folder in candidate.GetDirectoryEntries())
{
if (!folder.IsDirectory)
{
continue;
}
// Cache entries are usually name@version, but git and local tarball packages don't
// have versions, so are name@hash and name@hash-timestamp, respectively. Packages
// in the Packages folder don't usually have a version, but can do, and things will
// still work, so try and find one
var nameAndSuffix = folder.RelativePath.Name.Split('@');
if (nameAndSuffix.Length != 2)
{
continue;
}
var name = nameAndSuffix[0];
var suffix = nameAndSuffix[1];
// If the suffix is a version, use it to pick the latest version. If not, pick an
// arbitrary cache entry. There is no guarantee that either method gets the right
// cache entry, but it's the best we can do without proper package details
if (JetSemanticVersion.TryParse(suffix, out var version) &&
result.TryGetValue(name, out var oldSuffix) &&
JetSemanticVersion.TryParse(oldSuffix, out var oldVersion) &&
oldVersion > version)
{
continue;
}
result[name] = suffix;
}
}
}
catch (Exception e)
{
myLogger.Error(e, "Exception during calculating unity shader include paths");
}
finally
{
myCacheSuffixes = result;
}
}
}
}
return(myCacheSuffixes.GetValueSafe(packageName));
}
