using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using StardewModdingAPI.Framework.ModHelpers; using StardewModdingAPI.Toolkit.Framework.Clients.WebApi; using StardewModdingAPI.Toolkit.Framework.ModData; using StardewModdingAPI.Toolkit.Framework.UpdateData; using StardewModdingAPI.Toolkit.Utilities; namespace StardewModdingAPI.Framework.ModLoading { /// Metadata for a mod. internal class ModMetadata : IModMetadata { /********* ** Fields *********/ /// The non-error issues with the mod, including warnings suppressed by the data record. private ModWarning ActualWarnings = ModWarning.None; /// The mod IDs which are listed as a requirement by this mod. The value for each pair indicates whether the dependency is required (i.e. not an optional dependency). private readonly Lazy> Dependencies; /********* ** Accessors *********/ /// public string DisplayName { get; } /// public string RootPath { get; } /// public string DirectoryPath { get; } /// public string RelativeDirectoryPath { get; } /// public IManifest Manifest { get; } /// public ModDataRecordVersionedFields? DataRecord { get; } /// public ModMetadataStatus Status { get; private set; } /// public ModFailReason? FailReason { get; private set; } /// public ModWarning Warnings => this.ActualWarnings & ~(this.DataRecord?.DataRecord.SuppressWarnings ?? ModWarning.None); /// public string? Error { get; private set; } /// public string? ErrorDetails { get; private set; } /// public bool IsIgnored { get; } /// public IMod? Mod { get; private set; } /// public IContentPack? ContentPack { get; private set; } /// public TranslationHelper? Translations { get; private set; } /// public IMonitor? Monitor { get; private set; } /// public object? Api { get; private set; } /// public ModEntryModel? UpdateCheckData { get; private set; } /// [MemberNotNullWhen(true, nameof(ModMetadata.ContentPack))] [SuppressMessage("ReSharper", "ConstantConditionalAccessQualifier", Justification = "The manifest may be null for broken mods while loading.")] public bool IsContentPack => this.Manifest?.ContentPackFor != null; /// The fake content packs created by this mod, if any. public ISet> FakeContentPacks { get; } = new HashSet>(); /********* ** Public methods *********/ /// Construct an instance. /// The mod's display name. /// The mod's full directory path within the . /// The root path containing mods. /// The mod manifest. /// Metadata about the mod from SMAPI's internal data (if any). /// Whether the mod folder should be ignored. This should be true if it was found within a folder whose name starts with a dot. public ModMetadata(string displayName, string directoryPath, string rootPath, IManifest? manifest, ModDataRecordVersionedFields? dataRecord, bool isIgnored) { this.DisplayName = displayName; this.DirectoryPath = directoryPath; this.RootPath = rootPath; this.RelativeDirectoryPath = PathUtilities.GetRelativePath(this.RootPath, this.DirectoryPath); this.Manifest = manifest!; // manifest may be null in low-level SMAPI code, but won't be null once it's received by mods via IModInfo this.DataRecord = dataRecord; this.IsIgnored = isIgnored; this.Dependencies = new Lazy>(this.ExtractDependencies); } /// public IModMetadata SetStatusFound() { this.SetStatus(ModMetadataStatus.Found, ModFailReason.Incompatible, null); this.FailReason = null; return this; } /// public IModMetadata SetStatus(ModMetadataStatus status, ModFailReason reason, string? error, string? errorDetails = null) { this.Status = status; this.FailReason = reason; this.Error = error; this.ErrorDetails = errorDetails; return this; } /// public IModMetadata SetWarning(ModWarning warning) { this.ActualWarnings |= warning; return this; } /// public IModMetadata SetMod(IMod mod, TranslationHelper translations) { if (this.ContentPack != null) throw new InvalidOperationException("A mod can't be both an assembly mod and content pack."); this.Mod = mod; this.Monitor = mod.Monitor; this.Translations = translations; return this; } /// public IModMetadata SetMod(IContentPack contentPack, IMonitor monitor, TranslationHelper translations) { if (this.Mod != null) throw new InvalidOperationException("A mod can't be both an assembly mod and content pack."); this.ContentPack = contentPack; this.Monitor = monitor; this.Translations = translations; return this; } /// public IModMetadata SetApi(object? api) { this.Api = api; return this; } /// public IModMetadata SetUpdateData(ModEntryModel data) { this.UpdateCheckData = data; return this; } /// [MemberNotNullWhen(true, nameof(IModInfo.Manifest))] public bool HasManifest() { return this.Manifest != null; } /// public bool HasID() { return this.HasManifest() && !string.IsNullOrWhiteSpace(this.Manifest.UniqueID); } /// public bool HasID(string? id) { return this.HasID() && string.Equals(this.Manifest.UniqueID.Trim(), id?.Trim(), StringComparison.OrdinalIgnoreCase); } /// public IEnumerable GetUpdateKeys(bool validOnly = false) { if (!this.HasManifest()) yield break; foreach (string rawKey in this.Manifest.UpdateKeys) { UpdateKey updateKey = UpdateKey.Parse(rawKey); if (updateKey.LooksValid || !validOnly) yield return updateKey; } } /// public bool HasRequiredModId(string modId, bool includeOptional) { return this.Dependencies.Value.TryGetValue(modId, out bool isRequired) && (includeOptional || isRequired); } /// public IEnumerable GetRequiredModIds(bool includeOptional = false) { foreach (var pair in this.Dependencies.Value) { if (includeOptional || pair.Value) yield return pair.Key; } } /// public bool HasValidUpdateKeys() { return this.GetUpdateKeys(validOnly: true).Any(); } /// public bool HasWarnings(params ModWarning[] warnings) { ModWarning curWarnings = this.Warnings; return warnings.Any(warning => curWarnings.HasFlag(warning)); } /// public string GetRelativePathWithRoot() { string rootFolderName = Path.GetFileName(this.RootPath); return Path.Combine(rootFolderName, this.RelativeDirectoryPath); } /// Get the currently live fake content packs created by this mod. public IEnumerable GetFakeContentPacks() { foreach (var reference in this.FakeContentPacks.ToArray()) { if (!reference.TryGetTarget(out ContentPack? pack)) { this.FakeContentPacks.Remove(reference); continue; } yield return pack; } } /********* ** Private methods *********/ /// Extract mod IDs from the manifest that must be installed to load this mod. /// Returns a dictionary of mod ID => is required (i.e. not an optional dependency). public IDictionary ExtractDependencies() { var ids = new Dictionary(StringComparer.OrdinalIgnoreCase); if (this.HasManifest()) { // yield dependencies foreach (IManifestDependency entry in this.Manifest.Dependencies) { if (!string.IsNullOrWhiteSpace(entry.UniqueID)) ids[entry.UniqueID] = entry.IsRequired; } // yield content pack parent if (!string.IsNullOrWhiteSpace(this.Manifest.ContentPackFor?.UniqueID)) ids[this.Manifest.ContentPackFor.UniqueID] = true; } return ids; } } }