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));
}
