private IEnumerable<VsTemplateWizardPackageInfo> GetPackages(XElement packagesElement) { var declarations = (from packageElement in packagesElement.ElementsNoNamespace("package") let id = packageElement.GetOptionalAttributeValue("id") let version = packageElement.GetOptionalAttributeValue("version") let skipAssemblyReferences = packageElement.GetOptionalAttributeValue("skipAssemblyReferences") select new { id, version, skipAssemblyReferences }).ToList(); SemanticVersion semVer; bool skipAssemblyReferencesValue; var missingOrInvalidAttributes = from declaration in declarations where String.IsNullOrWhiteSpace(declaration.id) || String.IsNullOrWhiteSpace(declaration.version) || !SemanticVersion.TryParse(declaration.version, out semVer) || (declaration.skipAssemblyReferences != null && !Boolean.TryParse(declaration.skipAssemblyReferences, out skipAssemblyReferencesValue)) select declaration; if (missingOrInvalidAttributes.Any()) { ShowErrorMessage( VsResources.TemplateWizard_InvalidPackageElementAttributes); throw new WizardBackoutException(); } return from declaration in declarations select new VsTemplateWizardPackageInfo( declaration.id, declaration.version, declaration.skipAssemblyReferences != null && Boolean.Parse(declaration.skipAssemblyReferences) ); }
private static List<ManifestDependency> ReadDependencies(XElement containerElement) { // element is <dependency> return (from element in containerElement.ElementsNoNamespace("dependency") select new ManifestDependency { Id = element.GetOptionalAttributeValue("id").SafeTrim(), Version = element.GetOptionalAttributeValue("version").SafeTrim() }).ToList(); }
private static List<ManifestDependency> ReadDependencies(XElement containerElement) { // element is <dependency> return (from element in containerElement.ElementsNoNamespace("dependency") let idElement = element.Attribute("id") where idElement != null && !String.IsNullOrEmpty(idElement.Value) select new ManifestDependency { Id = idElement.Value.SafeTrim(), Version = element.GetOptionalAttributeValue("version").SafeTrim() }).ToList(); }
private static List<ManifestDependencySet> ReadDependencySets(XElement dependenciesElement) { if (!dependenciesElement.HasElements) { return new List<ManifestDependencySet>(); } // 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.Count > 0) { // old format, <dependency> is direct child of <dependencies> var dependencySet = new ManifestDependencySet { Dependencies = dependencies }; return new List<ManifestDependencySet> { dependencySet }; } else { var groups = dependenciesElement.ElementsNoNamespace("group"); return (from element in groups select new ManifestDependencySet { TargetFramework = element.GetOptionalAttributeValue("targetFramework").SafeTrim(), Dependencies = ReadDependencies(element) }).ToList(); } }
public static List<ManifestReference> ReadReference(XElement referenceElement, bool throwIfEmpty) { var references = (from element in referenceElement.ElementsNoNamespace("reference") let fileAttribute = element.Attribute("file") where fileAttribute != null && !String.IsNullOrEmpty(fileAttribute.Value) select new ManifestReference { File = fileAttribute.Value.SafeTrim() } ).ToList(); if (throwIfEmpty && references.Count == 0) { throw new InvalidDataException(NuGetResources.Manifest_ReferencesIsEmpty); } return references; }
/// <summary> /// Parse dependencies from the xelement and returns a list of PackageDependencySet /// </summary> /// <param name="dependenciesElement"></param> /// <returns></returns> private static List<PackageDependencySet> ReadDependencyList(XElement dependenciesElement) { // No elements so return empty list if (!dependenciesElement.HasElements) { return new List<PackageDependencySet>(); } // Direct child of dependenciesElement with tag <group> var groups = dependenciesElement.ElementsNoNamespace("group"); // It is an error for <dependencies> element to contain both <dependency> and <group> child elements if (dependenciesElement.ElementsNoNamespace("dependency").Any() && groups.Any()) { throw new InvalidDataException(Messages.DependencyHasBothElements); } var dependencies = ReadDependencies(dependenciesElement); if (!groups.Any()) { // since there is no group, we are encoutering // old format, <dependency> is direct child of <dependencies> var dependencySet = new PackageDependencySet { Dependencies = dependencies }; return new List<PackageDependencySet> { dependencySet }; } else { // new format, with <group> as child of <dependencies> // Project each group into a packagedependencyset return groups.Select(group => new PackageDependencySet { TargetFramework = group.GetOptionalAttributeValue("targetFramework").SafeTrim(), Dependencies = ReadDependencies(group) }).ToList(); } }
private static List<ManifestContentFiles> ReadContentFiles(XElement contentFilesElement) { if (!contentFilesElement.HasElements) { return new List<ManifestContentFiles>(0); } var contentFileSets = (from element in contentFilesElement.ElementsNoNamespace("files") let includeAttribute = element.Attribute("include") where includeAttribute != null && !string.IsNullOrEmpty(includeAttribute.Value) let excludeAttribute = element.Attribute("exclude") let buildActionAttribute = element.Attribute("buildAction") let copyToOutputAttribute = element.Attribute("copyToOutput") let flattenAttribute = element.Attribute("flatten") select new ManifestContentFiles { Include = includeAttribute.Value?.Trim(), Exclude = excludeAttribute == null ? null : excludeAttribute.Value, BuildAction = buildActionAttribute == null ? null : buildActionAttribute.Value, CopyToOutput = copyToOutputAttribute == null ? null : copyToOutputAttribute.Value, Flatten = flattenAttribute == null ? null : flattenAttribute.Value }).ToList(); return contentFileSets; }
private static List<ManifestFrameworkAssembly> ReadFrameworkAssemblies(XElement frameworkElement) { if (!frameworkElement.HasElements) { return new List<ManifestFrameworkAssembly>(0); } return (from element in frameworkElement.ElementsNoNamespace("frameworkAssembly") let assemblyNameAttribute = element.Attribute("assemblyName") where assemblyNameAttribute != null && !String.IsNullOrEmpty(assemblyNameAttribute.Value) select new ManifestFrameworkAssembly { AssemblyName = assemblyNameAttribute.Value.SafeTrim(), TargetFramework = element.GetOptionalAttributeValue("targetFramework").SafeTrim() }).ToList(); }
private static List<ManifestReferenceSet> ReadReferenceSets(XElement referencesElement) { if (!referencesElement.HasElements) { return new List<ManifestReferenceSet>(0); } if (referencesElement.ElementsNoNamespace("group").Any() && referencesElement.ElementsNoNamespace("reference").Any()) { throw new InvalidDataException(NuGetResources.Manifest_ReferencesHasMixedElements); } var references = ReadReference(referencesElement, throwIfEmpty: false); if (references.Count > 0) { // old format, <reference> is direct child of <references> var referenceSet = new ManifestReferenceSet { References = references }; return new List<ManifestReferenceSet> { referenceSet }; } else { var groups = referencesElement.ElementsNoNamespace("group"); return (from element in groups select new ManifestReferenceSet { TargetFramework = element.GetOptionalAttributeValue("targetFramework").SafeTrim(), References = ReadReference(element, throwIfEmpty: true) }).ToList(); } }
private static List<ManifestReference> ReadReference(XElement referenceElement, bool throwIfEmpty) { var references = (from element in referenceElement.ElementsNoNamespace("reference") select new ManifestReference { File = element.GetOptionalAttributeValue("file").SafeTrim() } ).ToList(); if (throwIfEmpty && references.Count == 0) { throw new InvalidDataException(NuGetResources.Manifest_ReferencesIsEmpty); } return references; }
private static List<ManifestFile> ReadFilesList(XElement xElement) { if (xElement == null) { return null; } List<ManifestFile> files = new List<ManifestFile>(); foreach (var file in xElement.ElementsNoNamespace("file")) { var srcElement = file.Attribute("src"); if (srcElement == null || String.IsNullOrEmpty(srcElement.Value)) { continue; } string target = file.GetOptionalAttributeValue("target").SafeTrim(); string exclude = file.GetOptionalAttributeValue("exclude").SafeTrim(); // Multiple sources can be specified by using semi-colon separated values. files.AddRange(from source in srcElement.Value.Trim(';').Split(';') select new ManifestFile { Source = source.SafeTrim(), Target = target.SafeTrim(), Exclude = exclude.SafeTrim() }); } return files; }
/// <summary> /// Read the dependencies from xelement. Returns a list of dependencies /// </summary> /// <param name="containerElement"></param> /// <returns></returns> private static List<PackageDependency> ReadDependencies(XElement containerElement) { // list of dependency var dependencies = containerElement.ElementsNoNamespace("dependency"); return (from element in containerElement.ElementsNoNamespace("dependency") let idElement = element.Attribute("id") // Check that id is not null or empty where idElement != null && !String.IsNullOrEmpty(idElement.Value) // Project a PackageDependency based on that select new PackageDependency { Id = idElement.Value.SafeTrim(), DependencyVersion = DependencyVersion.ParseDependencyVersion(element.GetOptionalAttributeValue("version").SafeTrim()) }).ToList(); }
private IEnumerable<PreinstalledPackageInfo> GetPackages(XElement packagesElement) { var declarations = (from packageElement in packagesElement.ElementsNoNamespace("package") let id = packageElement.GetOptionalAttributeValue("id") let version = packageElement.GetOptionalAttributeValue("version") let skipAssemblyReferences = packageElement.GetOptionalAttributeValue("skipAssemblyReferences") let includeDependencies = packageElement.GetOptionalAttributeValue("includeDependencies") select new { id, version, skipAssemblyReferences, includeDependencies }).ToList(); NuGetVersion semVer = null; bool skipAssemblyReferencesValue; bool includeDependenciesValue; var missingOrInvalidAttributes = from declaration in declarations where String.IsNullOrWhiteSpace(declaration.id) || String.IsNullOrWhiteSpace(declaration.version) || !NuGetVersion.TryParse(declaration.version, out semVer) || (declaration.skipAssemblyReferences != null && !Boolean.TryParse(declaration.skipAssemblyReferences, out skipAssemblyReferencesValue)) || (declaration.includeDependencies != null && !Boolean.TryParse(declaration.includeDependencies, out includeDependenciesValue)) select declaration; if (missingOrInvalidAttributes.Any()) { ShowErrorMessage( VsResources.TemplateWizard_InvalidPackageElementAttributes); throw new WizardBackoutException(); } return from declaration in declarations select new PreinstalledPackageInfo( declaration.id, declaration.version, skipAssemblyReferences: declaration.skipAssemblyReferences != null && Boolean.Parse(declaration.skipAssemblyReferences), // Note that the declaration uses "includeDependencies" but we need to invert it to become ignoreDependencies // The declaration uses includeDependencies so that the default value can be 'false' ignoreDependencies: !(declaration.includeDependencies != null && Boolean.Parse(declaration.includeDependencies)) ); }
private static List<PackageDependency> ReadDependencies(XElement containerElement) { // element is <dependency> return (from element in containerElement.ElementsNoNamespace("dependency") let idElement = element.Attribute("id") where idElement != null && !string.IsNullOrEmpty(idElement.Value) select new PackageDependency( idElement.Value?.Trim(), element.GetOptionalAttributeValue("version")?.Trim()) ).ToList(); }
public static List<ManifestReference> ReadReference(XElement referenceElement) { return (from element in referenceElement.ElementsNoNamespace("reference") select new ManifestReference { File = element.GetOptionalAttributeValue("file").SafeTrim() } ).ToList(); }
private static List<FrameworkAssemblyReference> ReadFrameworkAssemblies(XElement frameworkElement) { if (!frameworkElement.HasElements) { return new List<FrameworkAssemblyReference>(0); } return frameworkElement.ElementsNoNamespace("frameworkAssembly") .Where(element => element.Attribute("assemblyName") != null) .Select(element => { var assemblyName = ((string)element.Attribute("assemblyName")).Trim(); var targetFrameworks = ((string)element.Attribute("targetFramework")) ?.Trim() ?.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries) ?.Select(VersionUtility.ParseFrameworkName); return new FrameworkAssemblyReference(assemblyName, targetFrameworks ?? Enumerable.Empty<FrameworkName>()); }) .ToList(); }
public static List<string> ReadReference(XElement referenceElement, bool throwIfEmpty) { var references = referenceElement.ElementsNoNamespace("reference") .Select(element => ((string)element.Attribute("file"))?.Trim()) .Where(file => file != null) .ToList(); if (throwIfEmpty && references.Count == 0) { throw new InvalidDataException(NuGetResources.Manifest_ReferencesIsEmpty); } return references; }
private static List<PackageReferenceSet> ReadReferenceSets(XElement referencesElement) { if (!referencesElement.HasElements) { return new List<PackageReferenceSet>(0); } if (referencesElement.ElementsNoNamespace("group").Any() && referencesElement.ElementsNoNamespace("reference").Any()) { throw new InvalidDataException(NuGetResources.Manifest_ReferencesHasMixedElements); } var references = ReadReference(referencesElement, throwIfEmpty: false); if (references.Any()) { // old format, <reference> is direct child of <references> var referenceSet = new PackageReferenceSet(references); return new List<PackageReferenceSet> { referenceSet }; } else { var groups = referencesElement.ElementsNoNamespace("group"); return groups.Select(element => { var framework = element.GetOptionalAttributeValue("targetFramework")?.Trim(); if (framework != null) { return new PackageReferenceSet(VersionUtility.ParseFrameworkName(framework), ReadReference(element, throwIfEmpty: true)); } else { return new PackageReferenceSet(ReadReference(element, throwIfEmpty: true)); } }).ToList(); } }
private static List<FrameworkAssemblyReference> ReadFrameworkAssemblies(XElement frameworkElement) { if (!frameworkElement.HasElements) { return new List<FrameworkAssemblyReference>(0); } return (from element in frameworkElement.ElementsNoNamespace("frameworkAssembly") let assemblyNameAttribute = element.Attribute("assemblyName") where assemblyNameAttribute != null && !String.IsNullOrEmpty(assemblyNameAttribute.Value) select new FrameworkAssemblyReference(assemblyNameAttribute.Value?.Trim(), new[] { NuGetFramework.Parse(element.GetOptionalAttributeValue("targetFramework")?.Trim()) }) ).ToList(); }
private static List<PackageDependency> ReadDependencies(XElement containerElement) { // element is <dependency> return (from element in containerElement.ElementsNoNamespace("dependency") let idElement = element.Attribute("id") where idElement != null && !String.IsNullOrEmpty(idElement.Value) select new PackageDependency( idElement.Value?.Trim(), VersionRange.Parse(element.GetOptionalAttributeValue("version")?.Trim()), element.GetOptionalAttributeValue("include")?.Trim()?.Split(',').Select(a => a.Trim()).ToArray(), element.GetOptionalAttributeValue("exclude")?.Trim()?.Split(',').Select(a => a.Trim()).ToArray() )).ToList(); }