/// <summary>
/// Loads the specified package into the engine.
/// </summary>
/// <param name="package">The package to load.</param>
public void LoadPackage(RantPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_loadedPackages.Contains(RantPackageDependency.Create(package)))
{
return;
}
foreach (var dependency in package.GetDependencies())
{
if (!_resolver.TryResolvePackage(dependency, out RantPackage pkg))
{
throw new FileNotFoundException(GetString("err-unresolvable-package", package, dependency));
}
LoadPackage(pkg);
}
foreach (var res in package.GetResources())
{
res.Load(this);
}
_loadedPackages.Add(RantPackageDependency.Create(package));
}
/// <summary>
/// Removes the specified dependency from the package.
/// </summary>
/// <param name="dependency">The dependency to remove.</param>
/// <returns></returns>
public bool RemoveDependency(RantPackageDependency dependency)
{
if (dependency == null)
{
throw new ArgumentNullException(nameof(dependency));
}
return(_dependencies.Remove(dependency));
}
/// <summary>
/// Adds the specified dependency to the package.
/// </summary>
/// <param name="dependency">The dependency to add.</param>
public void AddDependency(RantPackageDependency dependency)
{
if (dependency == null)
{
throw new ArgumentNullException(nameof(dependency));
}
_dependencies.Add(dependency);
}
/// <summary>
/// Determines whether the package has the specified dependency.
/// </summary>
/// <param name="dependency">The dependency to check for.</param>
/// <returns></returns>
public bool DependsOn(RantPackageDependency dependency)
{
if (dependency == null)
{
throw new ArgumentNullException(nameof(dependency));
}
return(_dependencies.Contains(dependency));
}
/// <summary>
/// Loads the specified package into the engine.
/// </summary>
/// <param name="package">The package to load.</param>
/// <param name="mergeBehavior">The table merging strategy to employ.</param>
public void LoadPackage(RantPackage package, TableMergeBehavior mergeBehavior = TableMergeBehavior.Naive)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (_loadedPackages.Contains(RantPackageDependency.Create(package)))
{
return;
}
var patterns = package.GetPatterns();
var tables = package.GetTables();
if (patterns.Any())
{
foreach (var pattern in patterns)
{
_patternCache[pattern.Name] = pattern;
if (pattern.Module != null)
{
PackageModules[pattern.Name] = pattern.Module;
}
}
}
if (tables.Any())
{
if (_dictionary == null)
{
_dictionary = new RantDictionary(tables, mergeBehavior);
}
else
{
foreach (var table in tables)
{
_dictionary.AddTable(table, mergeBehavior);
}
}
}
_loadedPackages.Add(RantPackageDependency.Create(package));
foreach (var dependency in package.GetDependencies())
{
RantPackage pkg;
if (!_resolver.TryResolvePackage(dependency, out pkg))
{
throw new FileNotFoundException($"Package '{package}' was unable to resolve dependency '{dependency}'");
}
LoadPackage(pkg, mergeBehavior);
}
}
/// <summary>
/// Attempts to resolve a depdendency to the appropriate package.
/// </summary>
/// <param name="depdendency">The depdendency to resolve.</param>
/// <param name="package">The package loaded from the depdendency.</param>
/// <returns></returns>
public virtual bool TryResolvePackage(RantPackageDependency depdendency, out RantPackage package)
{
package = null;
var path = Path.Combine(Environment.CurrentDirectory, $"{depdendency.ID}.rantpkg");
if (!File.Exists(path))
{
RantPackageVersion version;
// Fallback to name with version appended
#if UNITY
path = Directory.GetFiles(Environment.CurrentDirectory, $"{depdendency.ID}*.rantpkg", SearchOption.AllDirectories).FirstOrDefault(p =>
#else
path = Directory.EnumerateFiles(Environment.CurrentDirectory, "*.rantpkg", SearchOption.AllDirectories).FirstOrDefault(p =>
#endif
{
var match = FallbackRegex.Match(Path.GetFileNameWithoutExtension(p));
if (!match.Success)
{
return(false);
}
version = RantPackageVersion.Parse(match.Groups["version"].Value);
return((depdendency.AllowNewer && version >= depdendency.Version) || depdendency.Version == version);
});
if (path == null)
{
return(false);
}
}
try
{
var pkg = RantPackage.Load(path);
if (pkg.ID != depdendency.ID)
{
return(false);
}
if ((depdendency.AllowNewer && pkg.Version >= depdendency.Version) || pkg.Version == depdendency.Version)
{
package = pkg;
return(true);
}
return(false);
}
catch
{
return(false);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var array = JArray.Load(reader);
var list = new List<RantPackageDependency>();
foreach (var item in array)
{
var obj = item as JObject;
if (obj == null) continue;
var tId = obj["id"] as JValue;
if (tId == null) continue;
var tVersion = obj["version"] as JValue;
if (tVersion == null) continue;
var tAllowNewer = obj["allow-newer"] as JValue;
var dep = new RantPackageDependency(tId.Value.ToString(), tVersion.Value.ToString());
if (tAllowNewer != null && tAllowNewer.Type == JTokenType.Boolean)
dep.AllowNewer = (bool)tAllowNewer.Value;
list.Add(dep);
}
return list;
}
/// <summary>
/// Attempts to resolve a depdendency to the appropriate package.
/// </summary>
/// <param name="depdendency">The depdendency to resolve.</param>
/// <param name="package">The package loaded from the depdendency.</param>
/// <returns></returns>
public virtual bool TryResolvePackage(RantPackageDependency depdendency, out RantPackage package)
{
package = null;
var path = Path.Combine(Environment.CurrentDirectory, $"{depdendency.ID}.rantpkg");
if (!File.Exists(path))
{
RantPackageVersion version;
// Fallback to name with version appended
#if UNITY
path = Directory.GetFiles(Environment.CurrentDirectory, $"{depdendency.ID}*.rantpkg", SearchOption.AllDirectories).FirstOrDefault(p =>
#else
path = Directory.EnumerateFiles(Environment.CurrentDirectory, "*.rantpkg", SearchOption.AllDirectories).FirstOrDefault(p =>
#endif
{
var match = FallbackRegex.Match(Path.GetFileNameWithoutExtension(p));
if (!match.Success) return false;
version = RantPackageVersion.Parse(match.Groups["version"].Value);
return (depdendency.AllowNewer && version >= depdendency.Version) || depdendency.Version == version;
});
if (path == null) return false;
}
try
{
var pkg = RantPackage.Load(path);
if (pkg.ID != depdendency.ID) return false;
if ((depdendency.AllowNewer && pkg.Version >= depdendency.Version) || pkg.Version == depdendency.Version)
{
package = pkg;
return true;
}
return false;
}
catch
{
return false;
}
}
/// <summary>
/// Adds the specified dependency to the package.
/// </summary>
/// <param name="dependency">The dependency to add.</param>
public void AddDependency(RantPackageDependency dependency)
{
if (dependency == null) throw new ArgumentNullException(nameof(dependency));
_dependencies.Add(dependency);
}
/// <summary>
/// Removes the specified dependency from the package.
/// </summary>
/// <param name="dependency">The dependency to remove.</param>
/// <returns></returns>
public bool RemoveDependency(RantPackageDependency dependency)
{
if (dependency == null) throw new ArgumentNullException(nameof(dependency));
return _dependencies.Remove(dependency);
}
/// <summary>
/// Determines whether the package has the specified dependency.
/// </summary>
/// <param name="dependency">The dependency to check for.</param>
/// <returns></returns>
public bool DependsOn(RantPackageDependency dependency)
{
if (dependency == null) throw new ArgumentNullException(nameof(dependency));
return _dependencies.Contains(dependency);
}
