public DependencyNode(
NodejsProjectNode root,
DependencyNode parent,
IPackage package)
: base(root) {
_projectNode = root;
_parent = parent;
Package = package;
_displayString = GetInitialPackageDisplayString(package);
ExcludeNodeFromScc = true;
}
public DependencyNode(
NodejsProjectNode root,
DependencyNode parent,
IPackage package)
: base(root) {
_projectNode = root;
_parent = parent;
Package = package;
var buff = new StringBuilder(package.Name);
if (package.IsMissing) {
buff.Append(" (missing)");
} else {
buff.Append('@');
buff.Append(package.Version);
if (!package.IsListedInParentPackageJson) {
buff.AppendFormat(" (not listed in {0})", NodejsConstants.PackageJsonFile);
} else {
List<string> dependencyTypes = new List<string>(3);
if (package.IsDependency) {
dependencyTypes.Add("standard");
}
if (package.IsDevDependency) {
dependencyTypes.Add("dev");
}
if (package.IsOptionalDependency) {
dependencyTypes.Add("optional");
}
if (package.IsDevDependency || package.IsOptionalDependency) {
buff.Append(" (");
buff.Append(string.Join(", ", dependencyTypes.ToArray()));
buff.Append(")");
}
}
}
if (package.IsBundledDependency) {
buff.Append("[bundled]");
}
_displayString = buff.ToString();
ExcludeNodeFromScc = true;
}
public async System.Threading.Tasks.Task UninstallModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
DoPreCommandActions();
try {
using (var commander = NpmController.CreateNpmCommander()) {
if (node.GetPropertiesObject().IsGlobalInstall) {
await commander.UninstallGlobalPackageAsync(node.Package.Name);
} else {
await commander.UninstallPackageAsync(node.Package.Name);
}
}
} catch (NpmNotFoundException nnfe) {
ErrorHelper.ReportNpmNotInstalled(null, nnfe);
} finally {
AllowCommands();
}
}
public async System.Threading.Tasks.Task InstallMissingModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
var root = _npmController.RootPackage;
if (null == root) {
return;
}
var pkgJson = root.PackageJson;
if (null == pkgJson) {
return;
}
var package = node.Package;
var dep = root.PackageJson.AllDependencies[package.Name];
DoPreCommandActions();
try {
using (var commander = NpmController.CreateNpmCommander()) {
if (node.GetPropertiesObject().IsGlobalInstall) {
// I genuinely can't see a way this would ever happen but, just to be on the safe side...
await commander.InstallGlobalPackageByVersionAsync(
package.Name,
null == dep ? "*" : dep.VersionRangeText);
} else {
await commander.InstallPackageByVersionAsync(
package.Name,
null == dep ? "*" : dep.VersionRangeText,
DependencyType.Standard,
false);
}
}
} catch (NpmNotFoundException nnfe) {
ErrorHelper.ReportNpmNotInstalled(null, nnfe);
} finally {
AllowCommands();
}
}
private bool CheckValidCommandTarget(DependencyNode node) {
if (null == node) {
return false;
}
var props = node.GetPropertiesObject();
if (null == props || props.IsSubPackage) {
return false;
}
var package = node.Package;
if (null == package) {
return false;
}
return true;
}
private IEnumerable<IPackage> BuildModuleHierarchy(HierarchyNode parent, IEnumerable<IPackage> modules, IReadOnlyDictionary<string, DependencyNode> recycle)
{
if (modules == null) {
return Enumerable.Empty<IPackage>();
}
var newModules = new List<IPackage>();
foreach (var package in modules) {
DependencyNode child;
if (recycle.ContainsKey(package.Name)) {
child = recycle[package.Name];
child.Package = package;
} else {
child = new DependencyNode(_projectNode, parent as DependencyNode, package);
parent.AddChild(child);
newModules.Add(package);
}
ReloadHierarchy(child, package.Modules);
if (ProjectMgr.ParentHierarchy != null) {
child.ExpandItem(EXPANDFLAGS.EXPF_CollapseFolder);
}
}
return newModules;
}
internal DependencyNodeProperties(DependencyNode node) : base(node) {}
internal DependencyNodeProperties(DependencyNode node) : base(node)
{
}
public async System.Threading.Tasks.Task UpdateModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
DoPreCommandActions();
try {
using (var commander = NpmController.CreateNpmCommander()) {
await commander.UpdatePackagesAsync(new[] { node.Package });
}
} catch (NpmNotFoundException nnfe) {
ErrorHelper.ReportNpmNotInstalled(null, nnfe);
} finally {
AllowCommands();
}
}
public async System.Threading.Tasks.Task InstallMissingModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
var root = _npmController.RootPackage;
if (null == root) {
return;
}
var pkgJson = root.PackageJson;
if (null == pkgJson) {
return;
}
var package = node.Package;
var dep = root.PackageJson.AllDependencies[package.Name];
DoPreCommandActions();
try {
using (var commander = NpmController.CreateNpmCommander()) {
await commander.InstallPackageByVersionAsync(
package.Name,
null == dep ? "*" : dep.VersionRangeText,
DependencyType.Standard,
false);
}
} catch (NpmNotFoundException nnfe) {
ErrorHelper.ReportNpmNotInstalled(null, nnfe);
} finally {
AllowCommands();
}
}
public async System.Threading.Tasks.Task UninstallModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
await RunNpmCommand(async commander => {
await commander.UninstallPackageAsync(node.Package.Name);
});
}
public async System.Threading.Tasks.Task UpdateModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
await RunNpmCommand(async commander => {
await commander.UpdatePackagesAsync(new[] { node.Package });
});
}
public async System.Threading.Tasks.Task InstallMissingModule(DependencyNode node) {
if (!CheckValidCommandTarget(node)) {
return;
}
var root = _npmController.RootPackage;
if (null == root) {
return;
}
var pkgJson = root.PackageJson;
if (null == pkgJson) {
return;
}
var package = node.Package;
var dep = root.PackageJson.AllDependencies[package.Name];
await RunNpmCommand(async commander => {
await commander.InstallPackageByVersionAsync(
package.Name,
null == dep ? "*" : dep.VersionRangeText,
DependencyType.Standard,
false);
});
}
protected void ReloadHierarchy(HierarchyNode parent, IEnumerable <IPackage> modules)
{
// We're going to reuse nodes for which matching modules exist in the new set.
// The reason for this is that we want to preserve the expansion state of the
// hierarchy. If we just bin everything off and recreate it all from scratch
// it'll all be in the collapsed state, which will be annoying for users who
// have drilled down into the hierarchy
var recycle = new Dictionary <string, DependencyNode>();
var remove = new List <HierarchyNode>();
for (var current = parent.FirstChild; null != current; current = current.NextSibling)
{
var dep = current as DependencyNode;
if (null == dep)
{
if (!(current is GlobalModulesNode) && !(current is LocalModulesNode))
{
remove.Add(current);
}
continue;
}
if (modules != null && modules.Any(
module =>
module.Name == dep.Package.Name &&
module.Version == dep.Package.Version &&
module.IsBundledDependency == dep.Package.IsBundledDependency &&
module.IsDevDependency == dep.Package.IsDevDependency &&
module.IsListedInParentPackageJson == dep.Package.IsListedInParentPackageJson &&
module.IsMissing == dep.Package.IsMissing &&
module.IsOptionalDependency == dep.Package.IsOptionalDependency))
{
recycle[dep.Package.Name] = dep;
}
else
{
remove.Add(current);
}
}
foreach (var obsolete in remove)
{
parent.RemoveChild(obsolete);
ProjectMgr.OnItemDeleted(obsolete);
}
if (modules != null)
{
foreach (var package in modules)
{
DependencyNode child;
if (recycle.ContainsKey(package.Name))
{
child = recycle[package.Name];
child.Package = package;
}
else
{
child = new DependencyNode(_projectNode, parent as DependencyNode, package);
parent.AddChild(child);
}
ReloadHierarchy(child, package.Modules);
if (ProjectMgr.ParentHierarchy != null)
{
child.ExpandItem(EXPANDFLAGS.EXPF_CollapseFolder);
}
}
}
}
protected void ReloadHierarchy(HierarchyNode parent, IEnumerable<IPackage> modules) {
// We're going to reuse nodes for which matching modules exist in the new set.
// The reason for this is that we want to preserve the expansion state of the
// hierarchy. If we just bin everything off and recreate it all from scratch
// it'll all be in the collapsed state, which will be annoying for users who
// have drilled down into the hierarchy
var recycle = new Dictionary<string, DependencyNode>();
var remove = new List<HierarchyNode>();
for (var current = parent.FirstChild; null != current; current = current.NextSibling) {
var dep = current as DependencyNode;
if (null == dep) {
if (!(current is GlobalModulesNode) && !(current is LocalModulesNode)) {
remove.Add(current);
}
continue;
}
if (modules != null && modules.Any(
module =>
module.Name == dep.Package.Name
&& module.Version == dep.Package.Version
&& module.IsBundledDependency == dep.Package.IsBundledDependency
&& module.IsDevDependency == dep.Package.IsDevDependency
&& module.IsListedInParentPackageJson == dep.Package.IsListedInParentPackageJson
&& module.IsMissing == dep.Package.IsMissing
&& module.IsOptionalDependency == dep.Package.IsOptionalDependency)) {
recycle[dep.Package.Name] = dep;
} else {
remove.Add(current);
}
}
foreach (var obsolete in remove) {
parent.RemoveChild(obsolete);
ProjectMgr.OnItemDeleted(obsolete);
}
if (modules != null) {
foreach (var package in modules) {
DependencyNode child;
if (recycle.ContainsKey(package.Name)) {
child = recycle[package.Name];
child.Package = package;
}
else {
child = new DependencyNode(_projectNode, parent as DependencyNode, package);
parent.AddChild(child);
}
ReloadHierarchy(child, package.Modules);
if (ProjectMgr.ParentHierarchy != null) {
child.ExpandItem(EXPANDFLAGS.EXPF_CollapseFolder);
}
}
}
}
