private static IEnumerable <ValidationResult> ValidateCore(PackageMetadata packageMetadata)
        {
            // Validate the ID
            if (string.IsNullOrEmpty(packageMetadata.Id))
            {
                yield return(new ValidationResult(Strings.Manifest_MissingId));
            }
            else
            {
                if (packageMetadata.Id.Length > MaxPackageIdLength)
                {
                    yield return(new ValidationResult(Strings.Manifest_IdTooLong));
                }
                else if (!PackageIdValidator.IsValidPackageId(packageMetadata.Id))
                {
                    yield return(new ValidationResult(String.Format(
                                                          CultureInfo.CurrentCulture,
                                                          Strings.Manifest_InvalidId,
                                                          packageMetadata.Id)));
                }
            }

            // Check URL properties
            foreach (var result in CheckUrls(
                         packageMetadata.GetValueFromMetadata("IconUrl"),
                         packageMetadata.GetValueFromMetadata("ProjectUrl"),
                         packageMetadata.GetValueFromMetadata("LicenseUrl")))
            {
                yield return(result);
            }

            // Check version
            if (packageMetadata.Version == null)
            {
                var version = packageMetadata.GetValueFromMetadata("version");

                yield return(new ValidationResult(String.Format(
                                                      CultureInfo.CurrentCulture,
                                                      Strings.Manifest_InvalidVersion,
                                                      version)));
            }

            // Check dependency groups
            var dependencyGroups = packageMetadata.GetDependencyGroups();

            if (dependencyGroups != null)
            {
                foreach (var dependency in dependencyGroups.SelectMany(set => set.Packages))
                {
                    if (!PackageIdValidator.IsValidPackageId(dependency.Id))
                    {
                        yield return(new ValidationResult(String.Format(
                                                              CultureInfo.CurrentCulture,
                                                              Strings.Manifest_InvalidDependency,
                                                              dependency.Id,
                                                              dependency.VersionRange)));
                    }
                }
            }
        }
Пример #2
0
        private static IEnumerable<ValidationResult> ValidateCore(PackageMetadata packageMetadata)
        {
            // Validate the ID
            if (string.IsNullOrEmpty(packageMetadata.Id))
            {
                yield return new ValidationResult(Strings.Manifest_MissingId);
            }
            else
            {
                if (packageMetadata.Id.Length > MaxPackageIdLength)
                {
                    yield return new ValidationResult(Strings.Manifest_IdTooLong);
                }
                else if (!PackageIdValidator.IsValidPackageId(packageMetadata.Id))
                {
                    yield return new ValidationResult(String.Format(
                        CultureInfo.CurrentCulture,
                        Strings.Manifest_InvalidId,
                        packageMetadata.Id));
                }
            }

            // Check URL properties
            foreach (var result in CheckUrls(
                packageMetadata.GetValueFromMetadata("IconUrl"),
                packageMetadata.GetValueFromMetadata("ProjectUrl"), 
                packageMetadata.GetValueFromMetadata("LicenseUrl")))
            {
                yield return result;
            }

            // Check version
            if (packageMetadata.Version == null)
            {
                var version = packageMetadata.GetValueFromMetadata("version");

                yield return new ValidationResult(String.Format(
                    CultureInfo.CurrentCulture,
                    Strings.Manifest_InvalidVersion,
                    version));
            }

            // Check dependency groups
            var dependencyGroups = packageMetadata.GetDependencyGroups();
            if (dependencyGroups != null)
            {
                foreach (var dependency in dependencyGroups.SelectMany(set => set.Packages))
                {
                    if (!PackageIdValidator.IsValidPackageId(dependency.Id))
                    {
                        yield return new ValidationResult(String.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Manifest_InvalidDependency,
                            dependency.Id,
                            dependency.VersionRange));
                    }
                }
            }
        }
Пример #3
0
        private static IEnumerable <ValidationResult> ValidateCore(PackageMetadata packageMetadata)
        {
            // Validate the ID
            if (string.IsNullOrEmpty(packageMetadata.Id))
            {
                yield return(new ValidationResult(CoreStrings.Manifest_MissingId));
            }
            else
            {
                if (packageMetadata.Id.Length > NuGet.Packaging.PackageIdValidator.MaxPackageIdLength)
                {
                    yield return(new ValidationResult(CoreStrings.Manifest_IdTooLong));
                }
                else if (!PackageIdValidator.IsValidPackageId(packageMetadata.Id))
                {
                    yield return(new ValidationResult(String.Format(
                                                          CultureInfo.CurrentCulture,
                                                          CoreStrings.Manifest_InvalidId,
                                                          packageMetadata.Id)));
                }
            }

            // Check and validate URL properties
            foreach (var result in CheckUrls(
                         packageMetadata.GetValueFromMetadata("IconUrl"),
                         packageMetadata.GetValueFromMetadata("ProjectUrl"),
                         packageMetadata.GetValueFromMetadata("LicenseUrl")))
            {
                yield return(result);
            }

            // Check version
            if (packageMetadata.Version == null)
            {
                var version = packageMetadata.GetValueFromMetadata("version");

                yield return(new ValidationResult(String.Format(
                                                      CultureInfo.CurrentCulture,
                                                      CoreStrings.Manifest_InvalidVersion,
                                                      version)));
            }

            var versionValidationResult = ValidateVersion(packageMetadata.Version);

            if (versionValidationResult != null)
            {
                yield return(versionValidationResult);
            }

            // Check framework reference groups
            var frameworkReferenceGroups = packageMetadata.GetFrameworkReferenceGroups();

            if (frameworkReferenceGroups != null)
            {
                foreach (var frameworkReferenceGroup in frameworkReferenceGroups)
                {
                    var isUnsupportedFramework = frameworkReferenceGroup?.TargetFramework?.IsUnsupported;
                    if (isUnsupportedFramework.HasValue && isUnsupportedFramework.Value)
                    {
                        yield return(new ValidationResult(String.Format(
                                                              CultureInfo.CurrentCulture,
                                                              CoreStrings.Manifest_TargetFrameworkNotSupported,
                                                              frameworkReferenceGroup?.TargetFramework?.ToString())));
                    }
                }
            }

            // Check dependency groups
            var dependencyGroups = packageMetadata.GetDependencyGroups();

            if (dependencyGroups != null)
            {
                foreach (var dependencyGroup in dependencyGroups)
                {
                    // Keep track of duplicates
                    var dependencyIds = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

                    // Verify frameworks
                    var isUnsupportedFramework = dependencyGroup.TargetFramework?.IsUnsupported;
                    if (isUnsupportedFramework.HasValue && isUnsupportedFramework.Value)
                    {
                        yield return(new ValidationResult(String.Format(
                                                              CultureInfo.CurrentCulture,
                                                              CoreStrings.Manifest_TargetFrameworkNotSupported,
                                                              dependencyGroup.TargetFramework?.ToString())));
                    }

                    // Verify package id's and versions
                    foreach (var dependency in dependencyGroup.Packages)
                    {
                        bool duplicate = !dependencyIds.Add(dependency.Id);
                        if (duplicate)
                        {
                            yield return(new ValidationResult(String.Format(
                                                                  CultureInfo.CurrentCulture,
                                                                  CoreStrings.Manifest_DuplicateDependency,
                                                                  dependencyGroup.TargetFramework.GetShortFolderName(),
                                                                  dependency.Id)));
                        }

                        if (!PackageIdValidator.IsValidPackageId(dependency.Id))
                        {
                            yield return(new ValidationResult(String.Format(
                                                                  CultureInfo.CurrentCulture,
                                                                  CoreStrings.Manifest_InvalidDependency,
                                                                  dependency.Id,
                                                                  dependency.VersionRange.OriginalString)));
                        }

                        // Versions
                        if (dependency.VersionRange.MinVersion != null)
                        {
                            var versionRangeValidationResult = ValidateVersion(dependency.VersionRange.MinVersion);
                            if (versionRangeValidationResult != null)
                            {
                                yield return(versionRangeValidationResult);
                            }
                        }

                        if (dependency.VersionRange.MaxVersion != null &&
                            dependency.VersionRange.MaxVersion != dependency.VersionRange.MinVersion)
                        {
                            var versionRangeValidationResult = ValidateVersion(dependency.VersionRange.MaxVersion);
                            if (versionRangeValidationResult != null)
                            {
                                yield return(versionRangeValidationResult);
                            }
                        }
                    }
                }
            }
        }
Пример #4
0
        private static IEnumerable <ValidationResult> ValidateCore(PackageMetadata packageMetadata)
        {
            // Validate the ID
            if (string.IsNullOrEmpty(packageMetadata.Id))
            {
                yield return(new ValidationResult(Strings.Manifest_MissingId));
            }
            else
            {
                if (packageMetadata.Id.Length > MaxPackageIdLength)
                {
                    yield return(new ValidationResult(Strings.Manifest_IdTooLong));
                }
                else if (!PackageIdValidator.IsValidPackageId(packageMetadata.Id))
                {
                    yield return(new ValidationResult(String.Format(
                                                          CultureInfo.CurrentCulture,
                                                          Strings.Manifest_InvalidId,
                                                          packageMetadata.Id)));
                }
            }

            // Check URL properties
            foreach (var result in CheckUrls(
                         packageMetadata.GetValueFromMetadata("IconUrl"),
                         packageMetadata.GetValueFromMetadata("ProjectUrl"),
                         packageMetadata.GetValueFromMetadata("LicenseUrl")))
            {
                yield return(result);
            }

            // Check version
            if (packageMetadata.Version == null)
            {
                var version = packageMetadata.GetValueFromMetadata("version");

                yield return(new ValidationResult(String.Format(
                                                      CultureInfo.CurrentCulture,
                                                      Strings.Manifest_InvalidVersion,
                                                      version)));
            }

            // Check dependency groups
            var dependencyGroups = packageMetadata.GetDependencyGroups();

            if (dependencyGroups != null)
            {
                foreach (var dependencyGroup in dependencyGroups)
                {
                    // Keep track of duplicates
                    var dependencyIds = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

                    // Verify package id's
                    foreach (var dependency in dependencyGroup.Packages)
                    {
                        bool duplicate = !dependencyIds.Add(dependency.Id);
                        if (duplicate)
                        {
                            yield return(new ValidationResult(String.Format(
                                                                  CultureInfo.CurrentCulture,
                                                                  Strings.Manifest_DuplicateDependency,
                                                                  dependencyGroup.TargetFramework.GetShortFolderName(),
                                                                  dependency.Id)));
                        }

                        if (!PackageIdValidator.IsValidPackageId(dependency.Id))
                        {
                            yield return(new ValidationResult(String.Format(
                                                                  CultureInfo.CurrentCulture,
                                                                  Strings.Manifest_InvalidDependency,
                                                                  dependency.Id,
                                                                  dependency.VersionRange.OriginalString)));
                        }
                    }
                }
            }
        }
        private static IEnumerable<ValidationResult> ValidateCore(PackageMetadata packageMetadata)
        {
            // Validate the ID
            if (string.IsNullOrEmpty(packageMetadata.Id))
            {
                yield return new ValidationResult(Strings.Manifest_MissingId);
            }
            else
            {
                if (packageMetadata.Id.Length > MaxPackageIdLength)
                {
                    yield return new ValidationResult(Strings.Manifest_IdTooLong);
                }
                else if (!PackageIdValidator.IsValidPackageId(packageMetadata.Id))
                {
                    yield return new ValidationResult(String.Format(
                        CultureInfo.CurrentCulture,
                        Strings.Manifest_InvalidId,
                        packageMetadata.Id));
                }
            }

            // Check and validate URL properties
            foreach (var result in CheckUrls(
                packageMetadata.GetValueFromMetadata("IconUrl"),
                packageMetadata.GetValueFromMetadata("ProjectUrl"),
                packageMetadata.GetValueFromMetadata("LicenseUrl")))
            {
                yield return result;
            }

            // Check version
            if (packageMetadata.Version == null)
            {
                var version = packageMetadata.GetValueFromMetadata("version");

                yield return new ValidationResult(String.Format(
                    CultureInfo.CurrentCulture,
                    Strings.Manifest_InvalidVersion,
                    version));
            }
            if (packageMetadata.Version.IsSemVer200())
            {

                yield return new ValidationResult(String.Format(
                    CultureInfo.CurrentCulture,
                    Strings.Manifest_InvalidVersionSemVer200,
                    packageMetadata.Version.ToFullString()));
            }

            // Check framework reference groups
            var frameworkReferenceGroups = packageMetadata.GetFrameworkReferenceGroups();
            if (frameworkReferenceGroups != null)
            {
                foreach (var frameworkReferenceGroup in frameworkReferenceGroups)
                {
                    var isUnsupportedFramework = frameworkReferenceGroup?.TargetFramework?.IsUnsupported;
                    if (isUnsupportedFramework.HasValue && isUnsupportedFramework.Value)
                    {
                        yield return new ValidationResult(String.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Manifest_TargetFrameworkNotSupported,
                            frameworkReferenceGroup?.TargetFramework?.ToString()));
                    }
                }
            }

            // Check dependency groups
            var dependencyGroups = packageMetadata.GetDependencyGroups();
            if (dependencyGroups != null)
            {
                foreach (var dependencyGroup in dependencyGroups)
                {
                    // Keep track of duplicates
                    var dependencyIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

                    // Verify frameworks
                    var isUnsupportedFramework = dependencyGroup.TargetFramework?.IsUnsupported;
                    if (isUnsupportedFramework.HasValue && isUnsupportedFramework.Value)
                    {
                        yield return new ValidationResult(String.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Manifest_TargetFrameworkNotSupported,
                            dependencyGroup.TargetFramework?.ToString()));
                    }

                    // Verify package id's
                    foreach (var dependency in dependencyGroup.Packages)
                    {
                        bool duplicate = !dependencyIds.Add(dependency.Id);
                        if (duplicate)
                        {
                            yield return new ValidationResult(String.Format(
                                CultureInfo.CurrentCulture,
                                Strings.Manifest_DuplicateDependency,
                                dependencyGroup.TargetFramework.GetShortFolderName(),
                                dependency.Id));
                        }

                        if (!PackageIdValidator.IsValidPackageId(dependency.Id))
                        {
                            yield return new ValidationResult(String.Format(
                                CultureInfo.CurrentCulture,
                                Strings.Manifest_InvalidDependency,
                                dependency.Id,
                                dependency.VersionRange.OriginalString));
                        }
                    }
                }
            }
        }