public void Parse_returns_parsed_object()
{
var json = OneFile.Parse(GetBinaryFixture("blob", "bin"), TestData.Password);
Assert.NotNull(json["i"]);
Assert.NotNull(json["c"]);
}
private void UnZipOneFile(object _file)
{
OneFile oneFile = (OneFile)_file;
using (ZipInputStream zipInputStream = new ZipInputStream(File.Open(this.zipFileName, 3, 1, 3)))
{
for (int i = 0; i < oneFile.entryCounter; i++)
{
zipInputStream.GetNextEntry();
}
using (FileStream fileStream = File.Create(oneFile.filePath))
{
int num = 2048;
byte[] array = new byte[2048];
while (true)
{
try
{
num = zipInputStream.Read(array, 0, array.Length);
}
catch (Exception ex)
{
Debug.LogError("zipFile.Read " + ex.ToString());
break;
}
if (num <= 0)
{
break;
}
fileStream.Write(array, 0, num);
}
}
this.unZipProgress = (float)zipInputStream.get_Position() / (float)this.fileSize;
}
}
public void Decompress_returns_decompressed_data()
{
// Generated with bash
// $ echo -n decompressed | gzip -c - | base64
Assert.Equal("decompressed".ToBytes(),
OneFile.Decompress("H4sIANRVH1oAA0tJTc7PLShKLS5OTQEACojeBQwAAAA=".Decode64()));
}
public void Parse_returns_parsed_object()
{
var json = OneFile.Parse(TestData.Blob, TestData.Password);
Assert.That(json["i"], Is.Not.Null);
Assert.That(json["c"], Is.Not.Null);
}
public ProjectGenerator(string baseDir, string projDir)
{
this.baseDir = baseDir;
this.projDir = projDir;
this.projectFile = null;
this.projectFile = OneProjectFile.fromJson(OneJson.parse(OneFile.readText($"{projDir}/one.json")).asObject());
this.srcDir = $"{this.projDir}/{this.projectFile.sourceDir}";
this.outDir = $"{this.projDir}/{this.projectFile.outputDir}";
}
private void *LoadMaestro(void *addressToDecompressTo, ref OneFile thisPointer, int fileIndex)
{
bool shouldFree = _buffer.Get(GetSizeOfFile(fileIndex, ref thisPointer), out var newAddress);
var returnValue = _loadMaestroHook.OriginalFunction(newAddress, ref thisPointer, fileIndex);
if (shouldFree)
{
_buffer.FreeLargeObject();
}
return(returnValue);
}
private void *LoadHAnimation(int fileIndex, void *addressToDecompressTo, ref OneFile thisPointer)
{
bool isLargeObject = _buffer.Get(GetSizeOfFile(fileIndex, ref thisPointer), out var newAddress);
var returnValue = _loadHAnimationHook.OriginalFunction(fileIndex, newAddress, ref thisPointer);
if (isLargeObject)
{
_buffer.FreeLargeObject();
}
return(returnValue);
}
public void generate(string dstDir, ObjectValue model)
{
foreach (var fn in this.srcFiles)
{
var srcFn = $"{this.templateDir}/src/{fn}";
var dstFn = $"{dstDir}/{fn}";
if (this.meta.templateFiles.includes(fn))
{
var tmpl = new TemplateParser(OneFile.readText(srcFn)).parse();
var dstFile = tmpl.format(new VMContext(model));
OneFile.writeText(dstFn, dstFile);
}
else
{
OneFile.copy(srcFn, dstFn);
}
}
}
public static async Task <Compiler> initProject(string projectName, string sourceDir, string lang = "ts", string packagesDir = null)
{
if (lang != "ts")
{
throw new Error("Only typescript is supported.");
}
var compiler = new Compiler();
await compiler.init(packagesDir ?? $"{CompilerHelper.baseDir}packages/");
compiler.setupNativeResolver(OneFile.readText($"{CompilerHelper.baseDir}langs/NativeResolvers/typescript.ts"));
compiler.newWorkspace(projectName);
foreach (var file in OneFile.listFiles(sourceDir, true).filter(x => x.endsWith(".ts")))
{
compiler.addProjectFile(file, OneFile.readText($"{sourceDir}/{file}"));
}
return(compiler);
}
/* Implementation */
private int GetSizeOfFile(int fileIndex, ref OneFile thisPointer)
{
// Sometimes the game may request a file of index 0, despite indices starting at 2.
if (fileIndex < 2)
{
return(_buffer.AllocationSize);
}
// Note: The pointer to the start of file in thisPointer might not be initialized, but the other pointers e.g. Start of name section.
int fileEntry = fileIndex - 2;
var startOfFile = ((byte *)thisPointer.NameSectionHeaderPointer) - sizeof(OneArchiveHeader);
var oneArchive = new OneArchive(startOfFile);
var enumerator = oneArchive.GetFileEntryEnumerator();
// Move to correct entry.
for (int x = 0; x <= fileEntry; x++)
{
enumerator.MoveNext();
}
return(SDK.Prs.Estimate(enumerator.Current->GetCompressedDataPtr(), enumerator.Current->FileSize));
}
public async Task <PackageBundle> getAllCached()
{
var packages = new Dictionary <string, PackageContent> {
};
var allFiles = OneFile.listFiles(this.packagesDir, true);
foreach (var fn in allFiles)
{
var pathParts = fn.split(new RegExp("/")).ToList();
// [0]=implementations/interfaces, [1]=package-name, [2:]=path
if (pathParts.length() < 3)
{
continue;
}
var type = pathParts.shift();
var pkgDir = pathParts.shift();
if (type != "implementations" && type != "interfaces")
{
continue;
}
// skip e.g. bundle.json
var pkgIdStr = $"{type}/{pkgDir}";
var pkg = packages.get(pkgIdStr);
if (pkg == null)
{
var pkgDirParts = pkgDir.split(new RegExp("-")).ToList();
var version = pkgDirParts.pop().replace(new RegExp("^v"), "");
var pkgType = type == "implementations" ? PackageType.Implementation : PackageType.Interface;
var pkgId = new PackageId(pkgType, pkgDirParts.join("-"), version);
pkg = new PackageContent(pkgId, new Dictionary <string, string> {
}, true);
packages.set(pkgIdStr, pkg);
}
pkg.files.set(pathParts.join("/"), OneFile.readText($"{this.packagesDir}/{fn}"));
}
return(new PackageBundle(Object.values(packages)));
}
public void ParseJson_returns_parsed_json()
{
Assert.NotNull(OneFile.ParseJson("{}".ToBytes()));
}
public ProjectTemplate(string templateDir)
{
this.templateDir = templateDir;
this.meta = ProjectTemplateMeta.fromYaml(OneYaml.load(OneFile.readText($"{templateDir}/index.yaml")));
this.srcFiles = OneFile.listFiles($"{templateDir}/src", true);
}
public async Task generate()
{
// copy native source codes from one project
var nativeSrcDir = $"{this.projDir}/{this.projectFile.nativeSourceDir}";
foreach (var fn in OneFile.listFiles(nativeSrcDir, true))
{
OneFile.copy($"{nativeSrcDir}/{fn}", $"{this.outDir}/{fn}");
}
var generators = new IGenerator[] { ((IGenerator) new JavaGenerator()), ((IGenerator) new CsharpGenerator()), ((IGenerator) new PythonGenerator()), ((IGenerator) new PhpGenerator()) };
foreach (var tmplName in this.projectFile.projectTemplates)
{
var compiler = await CompilerHelper.initProject(this.projectFile.name, this.srcDir, this.projectFile.sourceLang, null);
compiler.processWorkspace();
var projTemplate = new ProjectTemplate($"{this.baseDir}/project-templates/{tmplName}");
var langId = projTemplate.meta.language;
var generator = generators.find(x => x.getLangName().toLowerCase() == langId);
var langName = generator.getLangName();
var outDir = $"{this.outDir}/{langName}";
foreach (var trans in generator.getTransforms())
{
trans.visitFiles(Object.values(compiler.projectPkg.files));
}
// copy implementation native sources
var oneDeps = new List <ImplementationPackage>();
var nativeDeps = new Dictionary <string, string> {
};
foreach (var dep in this.projectFile.dependencies)
{
var impl = compiler.pacMan.implementationPkgs.find(x => x.content.id.name == dep.name);
oneDeps.push(impl);
var langData = impl.implementationYaml.languages.get(langId);
if (langData == null)
{
continue;
}
foreach (var natDep in langData.nativeDependencies ?? new ImplPkgNativeDependency[0])
{
nativeDeps.set(natDep.name, natDep.version);
}
if (langData.nativeSrcDir != null)
{
if (projTemplate.meta.packageDir == null)
{
throw new Error("Package directory is empty in project template!");
}
var srcDir = langData.nativeSrcDir + (langData.nativeSrcDir.endsWith("/") ? "" : "/");
var dstDir = $"{outDir}/{projTemplate.meta.packageDir}/{langData.packageDir ?? impl.content.id.name}";
var depFiles = Object.keys(impl.content.files).filter(x => x.startsWith(srcDir)).map(x => x.substr(srcDir.length()));
foreach (var fn in depFiles)
{
OneFile.writeText($"{dstDir}/{fn}", impl.content.files.get($"{srcDir}{fn}"));
}
}
if (langData.generatorPlugins != null)
{
foreach (var genPlugFn in langData.generatorPlugins)
{
generator.addPlugin(new TemplateFileGeneratorPlugin(generator, impl.content.files.get(genPlugFn)));
}
}
}
// generate cross compiled source code
console.log($"Generating {langName} code...");
var files = generator.generate(compiler.projectPkg);
foreach (var file in files)
{
OneFile.writeText($"{outDir}/{projTemplate.meta.destinationDir ?? ""}/{file.path}", file.content);
}
// generate files from project template
var model = new ObjectValue(new Dictionary <string, IVMValue> {
["dependencies"] = ((IVMValue) new ArrayValue(Object.keys(nativeDeps).map(name => new ObjectValue(new Dictionary <string, IVMValue> {
["name"] = ((IVMValue) new StringValue(name)),
["version"] = ((IVMValue) new StringValue(nativeDeps.get(name)))
})))),
["onepackages"] = ((IVMValue) new ArrayValue(oneDeps.map(dep => new ObjectValue(new Dictionary <string, IVMValue> {
["vendor"] = ((IVMValue) new StringValue(dep.implementationYaml.vendor)),
["id"] = ((IVMValue) new StringValue(dep.implementationYaml.name))
}))))
});
projTemplate.generate($"{outDir}", model);
}
}
public void ParseJson_throws_on_invalid_json()
{
Assert.That(() => OneFile.ParseJson("}{".ToBytes()),
ExceptionsTest.ThrowsParseErrorWithMessage("Corrupted"));
}
private static TestDelegate Parse(byte[] content)
{
return(() => OneFile.Parse(content, "password"));
}
private static TestDelegate Decrypt(byte[] content)
{
return(() => OneFile.Decrypt(content, "password"));
}
private static void Decrypt(byte[] content)
{
OneFile.Decrypt(content, "password");
}
private static void Parse(byte[] content)
{
OneFile.Parse(content, "password");
}
public void ParseJson_returns_parsed_json()
{
Assert.That(OneFile.ParseJson("{}".ToBytes()), Is.Not.Null);
}
public void listXCompiledNativeSources()
{
console.log(OneFile.listFiles($"{this.baseDir}/xcompiled-src/native", true).join("\n"));
}
public void afterStage(string stageName)
{
console.log($"Stage finished: {stageName}");
OneFile.writeText($"{this.artifactDir}/stages/{this.stage}_{stageName}.txt", new PackageStateCapture(this.compiler.projectPkg).getSummary());
this.stage++;
}
public void ParseJson_throws_on_invalid_json()
{
Exceptions.AssertThrowsInternalError(() => OneFile.ParseJson("}{".ToBytes()), "Corrupted");
}
