private Package ConfigurePackage(ConfigBucketBase config, Package package) { package.SetPackageType(config.PackageType); package.SetReleaseDate(config.ReleaseDate); if (config.Source != null) { package.SetSourceType(config.Source.Type); package.SetSourceUri(config.Source.Uri); package.SetSourceReference(config.Source.Reference); package.SetSourceMirrors(config.Source.Mirrors); } if (config.Dist != null) { package.SetDistType(config.Dist.Type); package.SetDistUri(config.Dist.Uri); package.SetDistReference(config.Dist.Reference); package.SetDistShasum(config.Dist.Shasum); package.SetDistMirrors(config.Dist.Mirrors); } package.SetSuggests(config.Suggests); package.SetNotificationUri(config.NotificationUri); package.SetArchives(config.Archive); package.SetExtra(config.Extra); package.SetInstallationSource(config.InstallationSource); package.SetBinaries(config.Binaries); return(package); }
/// <summary> /// Initializes a new instance of the <see cref="InvalidPackageException"/> class. /// </summary> /// <param name="errors">An array of the errors.</param> /// <param name="warnings">An array of the warnings.</param> /// <param name="config">The bucket config instance.</param> public InvalidPackageException(string[] errors, string[] warnings, ConfigBucketBase config) : base() { this.errors = errors; this.warnings = warnings; this.config = config; }
/// <inheritdoc /> public virtual IPackage Load(ConfigBucketBase config, Type expectedClass) { var package = CreatePackage(config, expectedClass); package = ConfigurePackageLinks(config, package); package = ConfigurePackage(config, package); package = ConfigurePackageComplete(config, package); // todo: Determine the alias package. return(package); }
private Package CreatePackage(ConfigBucketBase config, Type type) { if (string.IsNullOrEmpty(config.VersionNormalized)) { config.VersionNormalized = versionParser.Normalize(config.Version); } if (!packageCreaters.TryGetValue(type, out PackageCreater creater)) { throw new RuntimeException($"Can not found creater with \"{type}\" type."); } return(creater(config.Name, config.VersionNormalized, config.Version)); }
private Package ConfigurePackageLinks(ConfigBucketBase config, Package package) { package.SetRequires( ParseLinks(config.Name, config.Version, nameof(config.Requires).ToLower(), config.Requires)); package.SetRequiresDev( ParseLinks(config.Name, config.Version, $"{Str.LowerDashes(nameof(config.RequiresDev))} (for development)", config.RequiresDev)); package.SetProvides( ParseLinks(config.Name, config.Version, nameof(config.Provides).ToLower(), config.Provides)); package.SetReplaces( ParseLinks(config.Name, config.Version, nameof(config.Replaces).ToLower(), config.Replaces)); package.SetConflicts( ParseLinks(config.Name, config.Version, nameof(config.Conflicts).ToLower(), config.Conflicts)); return(package); }
private Package ConfigurePackageComplete(ConfigBucketBase config, Package package) { if (!(package is PackageComplete packageComplete)) { return(package); } packageComplete.SetDescription(config.Description); packageComplete.SetHomepage(config.Homepage); packageComplete.SetDeprecated(config.Deprecated); packageComplete.SetKeyworkds(config.Keywords); packageComplete.SetAuthors(config.Authors); packageComplete.SetLicenses(config.Licenses); packageComplete.SetSupport(config.Support); packageComplete.SetScripts(config.Scripts); return(packageComplete); }
/// <inheritdoc /> public override IPackage Load(ConfigBucketBase config, Type expectedClass) { if (!typeof(IPackageRoot).IsAssignableFrom(expectedClass)) { throw new ArgumentException($"The type must implement \"{nameof(IPackageRoot)}\"."); } if (string.IsNullOrEmpty(config.Name)) { throw new RuntimeException("The \"name\" property not allowed to be empty."); } if (string.IsNullOrEmpty(config.Version)) { throw new RuntimeException("The \"version\" property not allowed to be empty."); } IPackage realPackage, package; realPackage = package = base.Load(config, expectedClass); if (realPackage is PackageAlias packageAlias) { realPackage = packageAlias.GetAliasOf(); } if (!(realPackage is PackageRoot packageRoot)) { throw new UnexpectedException($"The package type does not meet expectations and should be: {nameof(PackageRoot)}"); } if (config.MinimumStability != null) { packageRoot.SetMinimunStability(config.MinimumStability); } packageRoot.SetPlatforms(config.Platforms); var aliases = new List <ConfigAlias>(); var stabilityFlags = new Dictionary <string, Stabilities>(); var references = new Dictionary <string, string>(); var required = new HashSet <string>(); void ExtractRequire(Link[] links) { var requires = new Dictionary <string, string>(); foreach (var link in links) { required.Add(link.GetTarget().ToLower()); requires[link.GetTarget()] = link.GetConstraint().GetPrettyString(); } ExtractAliases(requires, aliases); ExtractStabilityFlags(requires, packageRoot.GetMinimumStability(), stabilityFlags); ExtractReferences(requires, references); } ExtractRequire(realPackage.GetRequires()); ExtractRequire(realPackage.GetRequiresDev()); if (required.Contains(config.Name.ToLower())) { throw new RuntimeException($"Root package \"{config.Name}\" cannot require itself in its bucket.json{Environment.NewLine}Did you accidentally name your root package after an external package?"); } packageRoot.SetAliases(aliases.ToArray()); packageRoot.SetStabilityFlags(stabilityFlags); packageRoot.SetReferences(references); packageRoot.SetPreferStable(config.PreferStable); var repositories = RepositoryFactory.CreateDefaultRepository(io, this.config, manager); foreach (var repository in repositories) { manager.AddRepository(repository); } packageRoot.SetRepositories(this.config.GetRepositories()); return(package); }
/// <summary> /// Converts a package from <see cref="ConfigBucket"/> instance. /// </summary> /// <typeparam name="T">The type which package will loaded.</typeparam> /// <param name="loader">The loader instance.</param> /// <param name="config">The config bucket instance.</param> /// <returns>Returns package instance.</returns> public static T Load <T>(this ILoaderPackage loader, ConfigBucketBase config) where T : class, IPackage { return((T)loader.Load(config, typeof(T))); }
/// <summary> /// Converts a package from <see cref="ConfigBucket"/> instance. /// </summary> /// <param name="loader">The loader instance.</param> /// <param name="config">The config bucket instance.</param> /// <returns>Returns package instance.</returns> public static IPackageComplete Load(this ILoaderPackage loader, ConfigBucketBase config) { return((IPackageComplete)loader.Load(config, typeof(IPackageComplete))); }
/// <inheritdoc /> /// <exception cref="InvalidPackageException">Triggered when validation fails.</exception> public IPackage Load(ConfigBucketBase config, Type expectedClass) { warnings.Clear(); errors.Clear(); // valid package name. if (string.IsNullOrEmpty(config.Name)) { errors.Add("The \"name\" property not allowed to be empty."); } else { var warning = GetPackageNamingDeprecationWarnings(config.Name); if (!string.IsNullOrEmpty(warning)) { warnings.Add(warning); } } // valid version. if (string.IsNullOrEmpty(config.Version)) { errors.Add("The \"version\" property not allowed to be empty."); } else { try { versionParser.Normalize(config.Version); } #pragma warning disable CA1031 catch (System.Exception ex) #pragma warning restore CA1031 { errors.Add($"Property \"version\" is invalid value ({config.Version}): {ex.Message}."); config.Version = null; config.VersionNormalized = null; } } // valid type. if (!string.IsNullOrEmpty(config.PackageType) && !ValidateRegex(config.PackageType, "type", "[A-Za-z0-9-]+")) { config.PackageType = null; } // valid authors. config.Authors = Arr.Filter(config.Authors ?? Array.Empty <ConfigAuthor>(), (author) => { if (!string.IsNullOrEmpty(author.Email) && !ValidateEmail(author.Email, $"Authors {author.Name}")) { author.Email = null; } return(!string.IsNullOrEmpty(author.Name)); }); // valid support. config.Support = Arr.Filter(config.Support, (support) => { var legal = new[] { "email", "issues", "forum", "source", "docs", "wiki" }; var channel = support.Key; if (!Array.Exists(legal, (item) => item == channel)) { warnings.Add($"Property \"{channel}\" is invalid, please use: {string.Join(", ", legal)}"); return(false); } if (channel == "email" && !ValidateEmail(support.Value, "Support")) { return(false); } return(true); }).ToDictionary(item => item.Key, item => item.Value); // valid link. IDictionary <string, string> ValidateLinks(IDictionary <string, string> collection, string linkType) { return(Arr.Filter(collection, (require) => { return ValidateLink(require.Key, require.Value, linkType); }).ToDictionary(item => item.Key, item => item.Value)); } config.Requires = ValidateLinks(config.Requires, "require"); config.RequiresDev = ValidateLinks(config.RequiresDev, "require-dev"); config.Replaces = ValidateLinks(config.Replaces, "replace"); config.Provides = ValidateLinks(config.Provides, "provide"); config.Conflicts = ValidateLinks(config.Conflicts, "conflict"); if (errors.Count > 0) { throw new InvalidPackageException(errors.ToArray(), warnings.ToArray(), config); } return(loader.Load(config, expectedClass)); }