public override Task Execute(Pipeline pipeline)
{
var resolvedArtifactPath = PathReference.ResolvePath(assemblyArtifactPath, pipeline, this);
var definitionDatums = pipeline.Manifest.Data.OfType <AssemblyDefinitions>().ToArray();
if (!definitionDatums.Any())
{
var scriptPath = UnityWebRequest.EscapeURL(AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(this)));
pipeline.Log(LogLevel.Warning, $"No AssemblyDefinitions found, skipping.");
return(Task.CompletedTask);
}
for (int i = 0; i < definitionDatums.Length; i++)
{
var datum = definitionDatums[i];
if (!datum)
{
continue;
}
var hasUnassignedDefinition = datum.definitions.Any(def => !(bool)def);
if (hasUnassignedDefinition)
{
pipeline.Log(LogLevel.Warning, $"AssemblyDefinitions with unassigned definition at index {i}");
}
}
return(Task.CompletedTask);
}
public override string GetPath(PathReference output, Pipeline pipeline)
{
string resolvedPath = PathReference.ResolvePath(path, pipeline, this);
string first = Directory.EnumerateDirectories(resolvedPath, searchPattern, searchOption).First();
return(first);
}
public override string GetPath(PathReference output, Pipeline pipeline)
{
string resolvedPath = PathReference.ResolvePath(path, pipeline, this);
string first = Directory.EnumerateDirectories(resolvedPath, searchPattern, searchOption)
.FirstOrDefault() ?? string.Empty;
return(first);
//return Directory.EnumerateDirectories("Packages", "bbepis-BepInExPack*", SearchOption.TopDirectoryOnly).First();
}
public PathReference GetOrCreateChildPath(string name)
{
if (!_subPaths.TryGetValue(name, out var zpr))
{
zpr = new PathReference();
_subPaths.Add(name, zpr);
}
return(zpr);
}
private void Initialize()
{
if (Directory.Exists(_root))
{
var files = Directory.GetFiles(_root, "*", SearchOption.AllDirectories);
if (files.Length > 0)
{
_rootZipDir = new PathReference();
}
foreach (var file in files)
{
if (!_cacheNormalFiles && !file.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
{
// skip any files that are not .zip files if we do not cache them all
continue;
}
var current = _rootZipDir;
var relativePath = file.ToLowerInvariant().MakeRelativePath(_root);
var parts = relativePath.Split(PathSeparators, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < parts.Length; i++)
{
var part = parts[i];
if (i == parts.Length - 1)
{
if (part.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
{
// this is the zip file, read the metadata!
var start = current;
var zf = new ZipFile(file);
_zipFiles.Add(zf);
foreach (ZipEntry entry in zf)
{
current = start;
var internalPath = entry.Name.Replace('/', '\\').ToLowerInvariant();
var internalParts = internalPath.Split(PathSeparators, StringSplitOptions.RemoveEmptyEntries);
for (int j = 0; j < internalParts.Length; j++)
{
var internalPart = internalParts[j];
if (j == internalParts.Length - 1)
{
if (entry.IsFile)
{
current.AddFile(internalPart, new FileEntry(internalPath, file, zf, entry));
}
else
{
current = current.GetOrCreateChildPath(internalPart);
}
}
else
{
current = current.GetOrCreateChildPath(internalPart);
}
}
}
}
else
{
current.AddFile(part, new FileEntry(file));
}
}
else
{
current = current.GetOrCreateChildPath(part);
}
}
}
}
}
// static functions
/// <summary>Determines whether two path references are equal.</summary>
/// <param name="a">The first path reference.</param>
/// <param name="b">The second path reference.</param>
/// <returns>A boolean indicating whether the path references are equal.</returns>
public static bool Equals(PathReference a, PathReference b)
{
if (a == null & b == null) {
return true;
} else if (a == null | b == null) {
return false;
} if (a is FileReference & b is FileReference) {
FileReference x = (FileReference)a;
FileReference y = (FileReference)b;
return x.Path == y.Path;
} else if (a is FolderReference & b is FolderReference) {
FolderReference x = (FolderReference)a;
FolderReference y = (FolderReference)b;
return x.Path == y.Path;
} else {
return false;
}
}
public override string GetPath(PathReference output, Pipeline pipeline) => "ThunderKit";
public override string GetPath(PathReference output, Pipeline pipeline) => ThunderKitSettings.GetOrCreateSettings <ThunderKitSettings>().GameExecutable;
public override string GetPath(PathReference output, Pipeline pipeline)
{
return(pipeline.Manifest.Identity.Version);
}
public override string GetPath(PathReference output, Pipeline pipeline) => AssetDatabase.GetAssetPath(Asset);
public override string GetPath(PathReference output, Pipeline pipeline) => pipeline.Manifest.Data.OfType <ThunderstoreManifest>().FirstOrDefault().versionNumber;
public override string GetPath(PathReference output, Pipeline pipeline) => Value;
public override string GetPath(PathReference output, Pipeline pipeline) => reference.GetPath(pipeline);
public override string GetPath(PathReference output, Pipeline pipeline) => pipeline.Manifest.Data.OfType <ManifestIdentity>().First().Name;
public override string GetPath(PathReference output, Pipeline pipeline) => pipeline.Manifest.name;
public override string GetPath(PathReference output, Pipeline pipeline) => value.Resolve(pipeline, this);
public override Task Execute(Pipeline pipeline)
{
AssetDatabase.SaveAssets();
var mainManifest = pipeline.Manifest;
var folderTrees = mainManifest.Data.OfType <LanguageFolderTree>().ToList();
var hasValidTreeFolders = folderTrees.Any(ft => ft.languageFolders.Any(lf => !lf.languageName.IsNullOrEmptyOrWhitespace() && lf.languageFiles.Any()));
if (!hasValidTreeFolders)
{
var scriptPath = UnityWebRequest.EscapeURL(AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(this)));
pipeline.Log(LogLevel.Warning, $"No valid LanguageTreeFolder defined, skipping {MarkdownUtils.GenerateAssetLink(nameof(StageLanguageFiles), scriptPath)} PipelineJob");
return(Task.CompletedTask);
}
var languageArtifactPath = PathReference.ResolvePath(LanguageArtifactPath, pipeline, this);
IOUtils.EnsureDirectory(languageArtifactPath);
var allLanguageFiles = folderTrees
.SelectMany(lft => lft.languageFolders)
.SelectMany(lf => lf.languageFiles)
.ToArray();
var logBuilder = new List <string>();
if (CheckForInvalidFiles(allLanguageFiles, out var invalidFiles))
{
foreach (var(asset, error) in invalidFiles)
{
var scriptPath = UnityWebRequest.EscapeURL(AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(this)));
switch (error)
{
case InvalidLangfile.InvalidExtension:
logBuilder.Add($"* File {MarkdownUtils.GenerateAssetLink(asset)} has an invalid extension ({Path.GetExtension(AssetDatabase.GetAssetPath(asset))}), extension should be either **\".txt\"** or **\".json\"**, skipping {MarkdownUtils.GenerateAssetLink(nameof(StageLanguageFiles), scriptPath)} PipelineJob");
break;
case InvalidLangfile.FormatError:
logBuilder.Add($"* File {MarkdownUtils.GenerateAssetLink(asset)} has JSON related format errors, skipping {MarkdownUtils.GenerateAssetLink(nameof(StageLanguageFiles), scriptPath)} PipelineJob");
break;
case InvalidLangfile.NodeError:
logBuilder.Add($"* File {MarkdownUtils.GenerateAssetLink(asset)} has an invalid JSON Node, the name for the json dictionary needs to be **\"strings\"**, skipping {MarkdownUtils.GenerateAssetLink(nameof(StageLanguageFiles), scriptPath)} PipelineJob");
break;
}
}
pipeline.Log(LogLevel.Warning, $"Found a total of {invalidFiles.Length} invalid language files on manifest {MarkdownUtils.GenerateAssetLink(mainManifest)}", logBuilder.ToArray());
logBuilder.Clear();
return(Task.CompletedTask);
}
foreach (var languageFolderTree in folderTrees)
{
string rootLanguageFolderPath = Path.Combine(languageArtifactPath, languageFolderTree.rootFolderName);
IOUtils.EnsureDirectory(rootLanguageFolderPath);
foreach (LanguageFolder languageFolder in languageFolderTree.languageFolders)
{
string langFolder = Path.Combine(rootLanguageFolderPath, languageFolder.languageName);
IOUtils.EnsureDirectory(langFolder);
foreach (TextAsset asset in languageFolder.languageFiles)
{
string relativeAssetPath = AssetDatabase.GetAssetPath(asset);
string fullAssetPath = Path.GetFullPath(relativeAssetPath);
string fullAssetName = Path.GetFileName(fullAssetPath);
string destPath = Path.Combine(langFolder, fullAssetName);
FileUtil.ReplaceFile(relativeAssetPath, destPath);
logBuilder.Add($"* Moved {MarkdownUtils.GenerateAssetLink(asset)} from ***{relativeAssetPath}*** to ***{destPath}***");
}
}
}
pipeline.Log(LogLevel.Information, $"Finished moving language files to {LanguageArtifactPath} ({languageArtifactPath})", logBuilder.ToArray());
logBuilder.Clear();
foreach (var languageFolderTree in folderTrees)
{
var languageNames = languageFolderTree.languageFolders.Select(lf => lf.languageName).ToArray();
foreach (var outputPath in languageFolderTree.StagingPaths.Select(path => path.Resolve(pipeline, this)))
{
foreach (string dirPath in Directory.GetDirectories(languageArtifactPath, "*", SearchOption.AllDirectories))
{
IOUtils.EnsureDirectory(dirPath.Replace(languageArtifactPath, outputPath));
}
foreach (string filePath in Directory.GetFiles(languageArtifactPath, "*", SearchOption.AllDirectories))
{
bool found = false;
foreach (var languageName in languageNames)
{
if (filePath.IndexOf(languageName, StringComparison.OrdinalIgnoreCase) >= 0)
{
found = true;
break;
}
}
if (!found)
{
continue;
}
string destFileName = filePath.Replace(languageArtifactPath, outputPath);
Directory.CreateDirectory(Path.GetDirectoryName(destFileName));
FileUtil.ReplaceFile(filePath, destFileName);
logBuilder.Add($"* Moved {Path.GetFileName(filePath)} from ***{filePath}*** to ***{destFileName}***");
}
}
}
pipeline.Log(LogLevel.Information, $"Finished moving language files to manifest's Staging Paths.", logBuilder.ToArray());
return(Task.CompletedTask);
}
public override string GetPath(PathReference output, Pipeline pipeline) => System.IO.Directory.GetCurrentDirectory();
