private static List <PackageDependencySet> ReadDependencySets(XElement dependenciesElement)
{
if (!dependenciesElement.HasElements)
{
return(new List <PackageDependencySet>());
}
// Disallow the <dependencies> element to contain both <dependency> and
// <group> child elements. Unfortunately, this cannot be enforced by XSD.
if (dependenciesElement.ElementsNoNamespace("dependency").Any() &&
dependenciesElement.ElementsNoNamespace("group").Any())
{
// TODO: Resources
throw new InvalidDataException("NuGetResources.Manifest_DependenciesHasMixedElements");
}
var dependencies = ReadDependencies(dependenciesElement);
if (dependencies.Count > 0)
{
// old format, <dependency> is direct child of <dependencies>
var dependencySet = new PackageDependencySet(dependencies);
return(new List <PackageDependencySet> {
dependencySet
});
}
else
{
var groups = dependenciesElement.ElementsNoNamespace("group");
return((from element in groups
select new PackageDependencySet(element.GetOptionalAttributeValue("targetFramework")?.Trim(),
ReadDependencies(element))).ToList());
}
}
private static string[] GetDependencies(PackageDependencySet coreDeps)
{
return coreDeps.Dependencies
.Select(d => d.Id)
.Where(d => !d.StartsWith("System."))
.Where(d => !d.StartsWith("Microsoft.NETCore."))
.Where(d => d != "NETStandard.Library")
.ToArray();
}
internal static IPackage CreatePackage(string id, string version, IEnumerable<PackageDependency> packageDependencies)
{
var package = Substitute.For<IPackage>();
package.Id.Returns(id);
package.Version.Returns(new SemanticVersion(version));
var packageDependencySet = new PackageDependencySet(null, packageDependencies);
package.DependencySets.Returns(new[] { packageDependencySet, });
return package;
}
public static IEnumerable<PackageDependency> GetCompatiblePackageDependencies(this IPackageMetadata package, FrameworkName targetFramework)
{
IEnumerable<PackageDependencySet> compatibleDependencySets;
if (targetFramework == null)
{
compatibleDependencySets = package.DependencySets;
}
else if (!VersionUtility.TryGetCompatibleItems(targetFramework, package.DependencySets, out compatibleDependencySets))
{
compatibleDependencySets = new PackageDependencySet[0];
}
return compatibleDependencySets.SelectMany(d => d.Dependencies);
}
public static IEnumerable <PackageDependency> GetCompatiblePackageDependencies(this IPackageMetadata package, FrameworkName targetFramework)
{
IEnumerable <PackageDependencySet> dependencySets;
if (targetFramework == null)
{
dependencySets = package.DependencySets;
}
else if (!VersionUtility.TryGetCompatibleItems <PackageDependencySet>(targetFramework, package.DependencySets, out dependencySets))
{
dependencySets = new PackageDependencySet[0];
}
return(from d in dependencySets select d.Dependencies);
}
public override void Context()
{
base.Context();
var packageDependencies = new List<PackageDependency>
{
fiddlerPackageDependency,
chocolateyPackageDependency
};
var packageDependencySet = new PackageDependencySet(new FrameworkName(".NETFramework, Version = 4.0"), packageDependencies);
package.Setup(p => p.DependencySets).Returns(
new List<PackageDependencySet>
{
packageDependencySet
});
}
private IEnumerable<string> ConvertDependencySetToStrings(PackageDependencySet dependencySet)
{
if (dependencySet.Dependencies.Count == 0)
{
if (dependencySet.TargetFramework != null)
{
// if this Dependency set is empty, we still need to send down one string of the form "::<target framework>",
// so that the client can reconstruct an empty group.
return new string[] { String.Format("::{0}", VersionUtility.GetShortFrameworkName(dependencySet.TargetFramework)) };
}
}
else
{
return dependencySet.Dependencies.Select(dependency => ConvertDependency(dependency, dependencySet.TargetFramework));
}
return new string[0];
}
public static Stream CreateSimplePackageStream(string id, string version = "1.0")
{
var packageBuilder = new PackageBuilder
{
Id = id,
Version = SemanticVersion.Parse(version),
Description = "Test description",
};
var dependencySet = new PackageDependencySet(VersionUtility.DefaultTargetFramework,
new PackageDependency[] {
new PackageDependency("Foo")
});
packageBuilder.DependencySets.Add(dependencySet);
packageBuilder.Authors.Add("foo");
var memoryStream = new MemoryStream();
packageBuilder.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream;
}
/// <summary>
/// Inserts a dependency set into the packagebuilder object, based on a dictionary
/// containing Id/version pairs (Newtonsoft.json, 5.0.6 for example).
/// </summary>
/// <param name="builder"></param>
/// <param name="packages"></param>
private void AddNugetDependencies(NuGet.PackageBuilder builder, Dictionary<string, string> packages)
{
//add dependencies
List<PackageDependency> dependencies = new List<PackageDependency>();
foreach (var package in packages)
{
dependencies.Add(new PackageDependency(package.Key, new VersionSpec {MinVersion = new SemanticVersion(package.Value), IsMinInclusive = true}));
}
var set = new PackageDependencySet(null, dependencies);
builder.DependencySets.Add(set);
}
private static IEnumerable<string> ConvertDependencySetToStrings(PackageDependencySet dependencySet)
{
if (dependencySet.Dependencies.Count == 0)
{
if (dependencySet.TargetFramework != null)
return new[] { String.Format("::{0}", VersionUtility.GetShortFrameworkName(dependencySet.TargetFramework)) };
}
else
return dependencySet.Dependencies.Select(dependency => ConvertDependency(dependency, dependencySet.TargetFramework));
return new string[0];
}
private NuGetFramework GetNuGetFramework(PackageDependencySet dependencySet)
{
NuGetFramework fxName = NuGetFramework.AnyFramework;
if (dependencySet.TargetFramework != null)
fxName = NuGetFramework.Parse(dependencySet.TargetFramework.FullName);
return fxName;
}
static void CreatePackage(PackageInfo package)
{
var packageBuilder = new PackageBuilder()
{
Id = package.Id,
Version = package.Version,
Description = "Some test package"
};
packageBuilder.Authors.Add("Outercurve Foundation");
string assemblySourcePath = GetAssemblyFullPath(package.FullName);
packageBuilder.Files.Add(new PhysicalPackageFile()
{
SourcePath = assemblySourcePath,
TargetPath = @"lib\" + Path.GetFileName(assemblySourcePath)
});
var set = new PackageDependencySet(VersionUtility.DefaultTargetFramework,
package.Dependencies.Select(dependency => new PackageDependency(dependency.Id, dependency.VersionSpec)));
packageBuilder.DependencySets.Add(set);
using (var stream = File.Create(GetPackageFileFullPath(package)))
{
packageBuilder.Save(stream);
}
}
private PackageBuilder CreatePackage()
{
PackageBuilder pb = new PackageBuilder();
pb.Id = Id;
pb.Version = new SemanticVersion(Version);
pb.Title = Title;
pb.Description = Description;
pb.Authors.AddRange(Authors.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
pb.Owners.AddRange(Owners.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
if (FrameworkAssemblies != null)
foreach (var fa in FrameworkAssemblies)
pb.FrameworkReferences.Add(new FrameworkAssemblyReference(fa.FrameworkName));
if (Dependencies != null)
{
var groups = new Dictionary<string, List<NuGetDependency>>();
foreach (var dpg in Dependencies)
{
string framework = dpg.TargetFramework;
if (String.IsNullOrWhiteSpace(framework))
framework = "";
List<NuGetDependency> list;
if (!groups.TryGetValue(framework, out list))
groups[framework] = list = new List<NuGetDependency>();
list.AddRange(dpg.Dependencies);
}
foreach (var g in groups)
{
FrameworkName fn = g.Key == "" ? null : VersionUtility.ParseFrameworkName(g.Key);
PackageDependencySet ds = new PackageDependencySet(fn, g.Value.Select(v => (PackageDependency)v));
pb.DependencySets.Add(ds);
}
}
if (Icon != null)
pb.IconUrl = Icon;
if (Url != null)
pb.ProjectUrl = Url;
if (License != null)
pb.LicenseUrl = License;
if (Summary != null)
pb.Summary = Summary;
if (Copyright != null)
pb.Copyright = Copyright;
if (ReleaseNotes != null)
pb.ReleaseNotes = ReleaseNotes;
return pb;
}
private static List<PackageDependencySet> ReadDependencySets(XElement dependenciesElement)
{
if (!dependenciesElement.HasElements)
{
return new List<PackageDependencySet>();
}
// Disallow the <dependencies> element to contain both <dependency> and
// <group> child elements. Unfortunately, this cannot be enforced by XSD.
if (dependenciesElement.ElementsNoNamespace("dependency").Any() &&
dependenciesElement.ElementsNoNamespace("group").Any())
{
throw new InvalidDataException(NuGetResources.Manifest_DependenciesHasMixedElements);
}
var dependencies = ReadDependencies(dependenciesElement);
if (dependencies.Any())
{
// old format, <dependency> is direct child of <dependencies>
var dependencySet = new PackageDependencySet(dependencies);
return new List<PackageDependencySet> { dependencySet };
}
else
{
var groups = dependenciesElement.ElementsNoNamespace("group");
return (from element in groups
select new PackageDependencySet(
element.GetOptionalAttributeValue("targetFramework")?.Trim(),
ReadDependencies(element))
).ToList();
}
}
public override void Context()
{
base.Context();
var packageDependencies = new List<PackageDependency>
{
packageDependencyWithNoVersion
};
var packageDependencySet = new PackageDependencySet(null, packageDependencies);
package.Setup(p => p.DependencySets).Returns(
new List<PackageDependencySet>
{
packageDependencySet
});
}
public EditablePackageDependencySet(PackageDependencySet packageDependencySet)
{
_targetFramework = packageDependencySet.TargetFramework;
_dependencies = new ObservableCollection<PackageDependency>(packageDependencySet.Dependencies);
}
