public void Edit(
FilePath manifest,
PackageId packageId,
NuGetVersion newNuGetVersion,
ToolCommandName[] newToolCommandNames)
{
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(manifest);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, manifest, manifest.GetDirectoryPath());
var existing = toolManifestPackages.Where(t => t.PackageId.Equals(packageId)).ToArray();
if (existing.Any())
{
var existingPackage = existing.Single();
if (existingPackage.PackageId.Equals(packageId))
{
var toEdit = deserializedManifest.Tools.Single(t => new PackageId(t.PackageId).Equals(packageId));
toEdit.Version = newNuGetVersion.ToNormalizedString();
toEdit.Commands = newToolCommandNames.Select(c => c.Value).ToArray();
}
}
else
{
throw new ArgumentException($"Manifest {manifest.Value} does not contain package id '{packageId}'.");
}
_fileSystem.File.WriteAllText(manifest.Value, deserializedManifest.ToJson());
}
public void Remove(FilePath fromFilePath, PackageId packageId)
{
SerializableLocalToolsManifest serializableLocalToolsManifest =
DeserializeLocalToolsManifest(fromFilePath);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(
serializableLocalToolsManifest,
fromFilePath,
fromFilePath.GetDirectoryPath());
if (!toolManifestPackages.Any(t => t.PackageId.Equals(packageId)))
{
throw new ToolManifestException(string.Format(
LocalizableStrings.CannotFindPackageIdInManifest, packageId));
}
if (serializableLocalToolsManifest.Tools == null)
{
throw new InvalidOperationException(
$"Invalid state {nameof(serializableLocalToolsManifest)} if out of sync with {nameof(toolManifestPackages)}. " +
$"{nameof(serializableLocalToolsManifest)} cannot be null when " +
$"the package id can be found in {nameof(toolManifestPackages)}.");
}
serializableLocalToolsManifest.Tools = serializableLocalToolsManifest.Tools
.Where(pair => !pair.Key.Equals(packageId.ToString(), StringComparison.Ordinal))
.ToDictionary(pair => pair.Key, pair => pair.Value);
_fileSystem.File.WriteAllText(
fromFilePath.Value,
serializableLocalToolsManifest.ToJson());
}
public void Remove(FilePath fromFilePath, PackageId packageId)
{
SerializableLocalToolsManifest serializableLocalToolsManifest =
DeserializeLocalToolsManifest(fromFilePath);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(
serializableLocalToolsManifest,
fromFilePath,
fromFilePath.GetDirectoryPath());
if (!toolManifestPackages.Any(t => t.PackageId.Equals(packageId)))
{
throw new ToolManifestException(string.Format(
LocalizableStrings.CannotFindPackageIdInManifest, packageId));
}
serializableLocalToolsManifest.Tools = serializableLocalToolsManifest.Tools
.Where(pair => !pair.Key.Equals(packageId.ToString(), StringComparison.Ordinal))
.ToDictionary(pair => pair.Key, pair => pair.Value);
_fileSystem.File.WriteAllText(
fromFilePath.Value,
JsonConvert.SerializeObject(serializableLocalToolsManifest, Formatting.Indented));
}
public bool TryFind(ToolCommandName toolCommandName, out ToolManifestPackage toolManifestPackage)
{
toolManifestPackage = default(ToolManifestPackage);
foreach (FilePath possibleManifest in EnumerateDefaultAllPossibleManifests())
{
if (!_fileSystem.File.Exists(possibleManifest.Value))
{
continue;
}
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(possibleManifest);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, possibleManifest);
foreach (var package in toolManifestPackages)
{
if (package.CommandNames.Contains(toolCommandName))
{
toolManifestPackage = package;
return(true);
}
}
if (deserializedManifest.isRoot.Value)
{
return(false);
}
}
return(false);
}
Read(FilePath manifest, DirectoryPath correspondingDirectory)
{
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(manifest);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(
deserializedManifest,
manifest,
correspondingDirectory);
return(toolManifestPackages, deserializedManifest.isRoot.Value);
}
public void Add(
FilePath to,
PackageId packageId,
NuGetVersion nuGetVersion,
ToolCommandName[] toolCommandNames)
{
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(to);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, to, to.GetDirectoryPath());
var existing = toolManifestPackages.Where(t => t.PackageId.Equals(packageId)).ToArray();
if (existing.Any())
{
var existingPackage = existing.Single();
if (existingPackage.PackageId.Equals(packageId) &&
existingPackage.Version == nuGetVersion &&
CommandNamesEqual(existingPackage.CommandNames, toolCommandNames))
{
return;
}
throw new ToolManifestException(string.Format(
LocalizableStrings.ManifestPackageIdCollision,
existingPackage.Version.ToNormalizedString(),
existingPackage.PackageId.ToString(),
to.Value,
nuGetVersion.ToNormalizedString()));
}
if (deserializedManifest.Tools == null)
{
deserializedManifest.Tools = new Dictionary <string, SerializableLocalToolSinglePackage>();
}
deserializedManifest.Tools.Add(
packageId.ToString(),
new SerializableLocalToolSinglePackage
{
Version = nuGetVersion.ToNormalizedString(),
Commands = toolCommandNames.Select(c => c.Value).ToArray()
});
_fileSystem.File.WriteAllText(to.Value, deserializedManifest.ToJson());
}
public IReadOnlyCollection <ToolManifestPackage> Find(FilePath?filePath = null)
{
IEnumerable <FilePath> allPossibleManifests =
filePath != null
? new[] { filePath.Value }
: EnumerateDefaultAllPossibleManifests();
bool findAnyManifest = false;
var result = new List <ToolManifestPackage>();
foreach (FilePath possibleManifest in allPossibleManifests)
{
if (!_fileSystem.File.Exists(possibleManifest.Value))
{
continue;
}
findAnyManifest = true;
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(possibleManifest);
List <ToolManifestPackage> toolManifestPackageFromOneManifestFile =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, possibleManifest);
foreach (ToolManifestPackage p in toolManifestPackageFromOneManifestFile)
{
if (!result.Any(addedToolManifestPackages =>
addedToolManifestPackages.PackageId.Equals(p.PackageId)))
{
result.Add(p);
}
}
if (deserializedManifest.isRoot.Value)
{
return(result);
}
}
if (!findAnyManifest)
{
throw new ToolManifestCannotBeFoundException(
string.Format(LocalizableStrings.CannotFindAnyManifestsFileSearched,
string.Join(Environment.NewLine, allPossibleManifests.Select(f => f.Value))));
}
return(result);
}
Read(FilePath manifest, DirectoryPath correspondingDirectory)
{
if (_dangerousFileDetector.IsDangerous(manifest.Value))
{
throw new ToolManifestException(
string.Format(LocalizableStrings.ManifestHasMarkOfTheWeb, manifest.Value));
}
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(manifest);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(
deserializedManifest,
manifest,
correspondingDirectory);
return(toolManifestPackages, deserializedManifest.IsRoot.Value);
}
private static void ValidateVersion(SerializableLocalToolsManifest deserializedManifest,
List <string> errors)
{
var deserializedManifestVersion = deserializedManifest.Version;
if (deserializedManifestVersion == null)
{
deserializedManifestVersion = DefaultToolManifestFileVersion;
}
if (deserializedManifestVersion == 0)
{
errors.Add(LocalizableStrings.ManifestVersion0);
}
if (deserializedManifestVersion > SupportedToolManifestFileVersion)
{
errors.Add(
string.Format(
LocalizableStrings.ManifestVersionHigherThanSupported,
deserializedManifestVersion, SupportedToolManifestFileVersion));
}
}
private List <ToolManifestPackage> GetToolManifestPackageFromOneManifestFile(
SerializableLocalToolsManifest deserializedManifest, FilePath path)
{
List <ToolManifestPackage> result = new List <ToolManifestPackage>();
var errors = new List <string>();
if (deserializedManifest.version == 0)
{
errors.Add(string.Format(LocalizableStrings.ManifestVersion0, path.Value));
}
if (deserializedManifest.version > SupportedVersion)
{
errors.Add(
string.Format(
LocalizableStrings.ManifestVersionHigherThanSupported,
deserializedManifest.version, SupportedVersion, path.Value));
}
foreach (KeyValuePair <string, SerializableLocalToolSinglePackage> tools in deserializedManifest.tools)
{
var packageLevelErrors = new List <string>();
var packageIdString = tools.Key;
var packageId = new PackageId(packageIdString);
string versionString = tools.Value.version;
NuGetVersion version = null;
if (versionString is null)
{
packageLevelErrors.Add(LocalizableStrings.ToolMissingVersion);
}
else
{
if (!NuGetVersion.TryParse(versionString, out version))
{
packageLevelErrors.Add(string.Format(LocalizableStrings.VersionIsInvalid, versionString));
}
}
NuGetFramework targetFramework = null;
var targetFrameworkString = tools.Value.targetFramework;
if (targetFrameworkString != null)
{
targetFramework = NuGetFramework.Parse(
targetFrameworkString);
if (targetFramework.IsUnsupported)
{
packageLevelErrors.Add(
string.Format(LocalizableStrings.TargetFrameworkIsUnsupported,
targetFrameworkString));
}
}
if (tools.Value.commands == null ||
(tools.Value.commands != null && tools.Value.commands.Length == 0))
{
packageLevelErrors.Add(LocalizableStrings.FieldCommandsIsMissing);
}
if (packageLevelErrors.Any())
{
var joinedWithIndentation = string.Join(Environment.NewLine,
packageLevelErrors.Select(e => "\t\t" + e));
errors.Add(string.Format(LocalizableStrings.InPackage, packageId.ToString(), joinedWithIndentation));
}
else
{
result.Add(new ToolManifestPackage(
packageId,
version,
ToolCommandName.Convert(tools.Value.commands)));
}
}
if (errors.Any())
{
throw new ToolManifestException(
string.Format(LocalizableStrings.InvalidManifestFilePrefix,
string.Join(Environment.NewLine, errors.Select(e => "\t" + e))));
}
return(result);
}
private List <ToolManifestPackage> GetToolManifestPackageFromOneManifestFile(
SerializableLocalToolsManifest deserializedManifest,
FilePath path,
DirectoryPath correspondingDirectory)
{
List <ToolManifestPackage> result = new List <ToolManifestPackage>();
var errors = new List <string>();
ValidateVersion(deserializedManifest, errors);
if (!deserializedManifest.IsRoot.HasValue)
{
errors.Add(string.Format(LocalizableStrings.ManifestMissingIsRoot, path.Value));
}
foreach (KeyValuePair <string, SerializableLocalToolSinglePackage> tools
in (deserializedManifest.Tools ?? new Dictionary <string, SerializableLocalToolSinglePackage>()))
{
var packageLevelErrors = new List <string>();
var packageIdString = tools.Key;
var packageId = new PackageId(packageIdString);
string versionString = tools.Value.Version;
NuGetVersion version = null;
if (versionString is null)
{
packageLevelErrors.Add(LocalizableStrings.ToolMissingVersion);
}
else
{
if (!NuGetVersion.TryParse(versionString, out version))
{
packageLevelErrors.Add(string.Format(LocalizableStrings.VersionIsInvalid, versionString));
}
}
if (tools.Value.Commands == null ||
(tools.Value.Commands != null && tools.Value.Commands.Length == 0))
{
packageLevelErrors.Add(LocalizableStrings.FieldCommandsIsMissing);
}
if (packageLevelErrors.Any())
{
var joinedWithIndentation = string.Join(Environment.NewLine,
packageLevelErrors.Select(e => "\t\t" + e));
errors.Add(string.Format(LocalizableStrings.InPackage, packageId.ToString(),
joinedWithIndentation));
}
else
{
result.Add(new ToolManifestPackage(
packageId,
version,
ToolCommandName.Convert(tools.Value.Commands),
correspondingDirectory));
}
}
if (errors.Any())
{
throw new ToolManifestException(
string.Format(LocalizableStrings.InvalidManifestFilePrefix,
path.Value,
string.Join(Environment.NewLine, errors.Select(e => "\t" + e))));
}
return(result);
}
private SerializableLocalToolsManifest DeserializeLocalToolsManifest(FilePath possibleManifest)
{
var serializableLocalToolsManifest = new SerializableLocalToolsManifest();
try
{
using (Stream jsonStream = _fileSystem.File.OpenRead(possibleManifest.Value))
using (JsonDocument doc = JsonDocument.Parse(jsonStream))
{
JsonElement root = doc.RootElement;
if (root.TryGetInt32Value(JsonPropertyVersion, out var version))
{
serializableLocalToolsManifest.Version = version;
}
if (root.TryGetBooleanValue(JsonPropertyIsRoot, out var isRoot))
{
serializableLocalToolsManifest.IsRoot = isRoot;
}
if (root.TryGetProperty(JsonPropertyTools, out var tools))
{
serializableLocalToolsManifest.Tools =
new Dictionary <string, SerializableLocalToolSinglePackage>();
if (tools.Type != JsonValueType.Object)
{
throw new ToolManifestException(
string.Format(LocalizableStrings.UnexpectedTypeInJson,
JsonValueType.Object.ToString(),
JsonPropertyTools));
}
foreach (var toolJson in tools.EnumerateObject())
{
var serializableLocalToolSinglePackage = new SerializableLocalToolSinglePackage();
if (toolJson.Value.TryGetStringValue(JsonPropertyVersion, out var versionJson))
{
serializableLocalToolSinglePackage.Version = versionJson;
}
var commands = new List <string>();
if (toolJson.Value.TryGetProperty(JsonPropertyCommands, out var commandsJson))
{
if (commandsJson.Type != JsonValueType.Array)
{
throw new ToolManifestException(
string.Format(LocalizableStrings.UnexpectedTypeInJson,
JsonValueType.Array.ToString(),
JsonPropertyCommands));
}
foreach (var command in commandsJson.EnumerateArray())
{
if (command.Type != JsonValueType.String)
{
throw new ToolManifestException(
string.Format(LocalizableStrings.UnexpectedTypeInJson,
JsonValueType.String.ToString(),
"command"));
}
commands.Add(command.GetString());
}
serializableLocalToolSinglePackage.Commands = commands.ToArray();
}
serializableLocalToolsManifest.Tools.Add(toolJson.Name, serializableLocalToolSinglePackage);
}
}
}
return(serializableLocalToolsManifest);
}
catch (Exception e) when(
e is JsonReaderException ||
e is ArgumentException) // "duplicated key"
{
throw new ToolManifestException(string.Format(LocalizableStrings.JsonParsingError,
possibleManifest.Value, e.Message));
}
}
public IReadOnlyCollection <ToolManifestPackage> Find(FilePath?filePath = null)
{
var result = new List <ToolManifestPackage>();
IEnumerable <FilePath> allPossibleManifests =
filePath != null
? new[] { filePath.Value }
: EnumerateDefaultAllPossibleManifests();
foreach (FilePath possibleManifest in allPossibleManifests)
{
if (_fileSystem.File.Exists(possibleManifest.Value))
{
SerializableLocalToolsManifest deserializedManifest = JsonConvert.DeserializeObject <SerializableLocalToolsManifest>(
_fileSystem.File.ReadAllText(possibleManifest.Value), new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore
});
var errors = new List <string>();
if (!deserializedManifest.isRoot)
{
errors.Add("isRoot is false is not supported.");
}
if (deserializedManifest.version != 1)
{
errors.Add(string.Format("Tools manifest format version {0} is not supported.",
deserializedManifest.version));
}
foreach (var tools in deserializedManifest.tools)
{
var packageLevelErrors = new List <string>();
var packageIdString = tools.Key;
var packageId = new PackageId(packageIdString);
string versionString = tools.Value.version;
NuGetVersion version = null;
if (versionString is null)
{
packageLevelErrors.Add(LocalizableStrings.MissingVersion);
}
else
{
var versionParseResult = NuGetVersion.TryParse(
versionString, out version);
if (!versionParseResult)
{
packageLevelErrors.Add(string.Format(LocalizableStrings.VersionIsInvalid, versionString));
}
}
if (tools.Value.commands == null ||
(tools.Value.commands != null && tools.Value.commands.Length == 0))
{
packageLevelErrors.Add(LocalizableStrings.FieldCommandsIsMissing);
}
if (packageLevelErrors.Any())
{
var joined = string.Join(string.Empty, packageLevelErrors.Select(e => Environment.NewLine + " " + e));
errors.Add(string.Format(LocalizableStrings.InPackage, packageId.ToString()) + joined);
}
else
{
result.Add(new ToolManifestPackage(
packageId,
version,
ToolCommandName.Convert(tools.Value.commands)));
}
}
if (errors.Any())
{
throw new ToolManifestException(LocalizableStrings.InvalidManifestFilePrefix +
string.Join(string.Empty, errors.Select(e => Environment.NewLine + " " + e)));
}
return(result);
}
}
throw new ToolManifestCannotFindException(
string.Format(LocalizableStrings.CannotFindAnyManifestsFileSearched,
string.Join(Environment.NewLine, allPossibleManifests.Select(f => f.Value))));
}
