550 lines
13 KiB
C++
550 lines
13 KiB
C++
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
|
|
#include <modutils.h>
|
|
|
|
#include "logger/QsLog.h"
|
|
#include "logic/VersionFile.h"
|
|
#include "logic/OneSixLibrary.h"
|
|
#include "logic/VersionFinal.h"
|
|
#include "MMCJson.h"
|
|
|
|
using namespace MMCJson;
|
|
|
|
#define CURRENT_MINIMUM_LAUNCHER_VERSION 14
|
|
|
|
RawLibrary RawLibrary::fromJson(const QJsonObject &libObj,
|
|
const QString &filename)
|
|
{
|
|
RawLibrary out;
|
|
if (!libObj.contains("name"))
|
|
{
|
|
throw JSONValidationError(filename +
|
|
"contains a library that doesn't have a 'name' field");
|
|
}
|
|
out.name = libObj.value("name").toString();
|
|
|
|
auto readString = [libObj, filename](const QString & key, QString & variable)
|
|
{
|
|
if (libObj.contains(key))
|
|
{
|
|
QJsonValue val = libObj.value(key);
|
|
if (!val.isString())
|
|
{
|
|
QLOG_WARN() << key << "is not a string in" << filename << "(skipping)";
|
|
}
|
|
else
|
|
{
|
|
variable = val.toString();
|
|
}
|
|
}
|
|
};
|
|
|
|
readString("url", out.url);
|
|
readString("MMC-hint", out.hint);
|
|
readString("MMC-absulute_url", out.absoluteUrl);
|
|
readString("MMC-absoluteUrl", out.absoluteUrl);
|
|
if (libObj.contains("extract"))
|
|
{
|
|
out.applyExcludes = true;
|
|
auto extractObj = ensureObject(libObj.value("extract"));
|
|
for (auto excludeVal : ensureArray(extractObj.value("exclude")))
|
|
{
|
|
out.excludes.append(ensureString(excludeVal));
|
|
}
|
|
}
|
|
if (libObj.contains("natives"))
|
|
{
|
|
out.applyNatives = true;
|
|
QJsonObject nativesObj = ensureObject(libObj.value("natives"));
|
|
for (auto it = nativesObj.begin(); it != nativesObj.end(); ++it)
|
|
{
|
|
if (!it.value().isString())
|
|
{
|
|
QLOG_WARN() << filename << "contains an invalid native (skipping)";
|
|
}
|
|
OpSys opSys = OpSys_fromString(it.key());
|
|
if (opSys != Os_Other)
|
|
{
|
|
out.natives.append(qMakePair(opSys, it.value().toString()));
|
|
}
|
|
}
|
|
}
|
|
if (libObj.contains("rules"))
|
|
{
|
|
out.applyRules = true;
|
|
out.rules = rulesFromJsonV4(libObj);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
VersionFile VersionFile::fromJson(const QJsonDocument &doc, const QString &filename,
|
|
const bool requireOrder, const bool isFTB)
|
|
{
|
|
VersionFile out;
|
|
if (doc.isEmpty() || doc.isNull())
|
|
{
|
|
throw JSONValidationError(filename + " is empty or null");
|
|
}
|
|
if (!doc.isObject())
|
|
{
|
|
throw JSONValidationError("The root of " + filename + " is not an object");
|
|
}
|
|
|
|
QJsonObject root = doc.object();
|
|
|
|
if (requireOrder)
|
|
{
|
|
if (root.contains("order"))
|
|
{
|
|
out.order = ensureInteger(root.value("order"));
|
|
}
|
|
else
|
|
{
|
|
// FIXME: evaluate if we don't want to throw exceptions here instead
|
|
QLOG_ERROR() << filename << "doesn't contain an order field";
|
|
}
|
|
}
|
|
|
|
out.name = root.value("name").toString();
|
|
out.fileId = root.value("fileId").toString();
|
|
out.version = root.value("version").toString();
|
|
out.mcVersion = root.value("mcVersion").toString();
|
|
out.filename = filename;
|
|
|
|
auto readString = [root, filename](const QString & key, QString & variable)
|
|
{
|
|
if (root.contains(key))
|
|
{
|
|
variable = ensureString(root.value(key));
|
|
}
|
|
};
|
|
|
|
// FIXME: This should be ignored when applying.
|
|
if (!isFTB)
|
|
{
|
|
readString("id", out.id);
|
|
}
|
|
|
|
readString("mainClass", out.mainClass);
|
|
readString("processArguments", out.processArguments);
|
|
readString("minecraftArguments", out.overwriteMinecraftArguments);
|
|
readString("+minecraftArguments", out.addMinecraftArguments);
|
|
readString("-minecraftArguments", out.removeMinecraftArguments);
|
|
readString("type", out.type);
|
|
readString("releaseTime", out.releaseTime);
|
|
readString("time", out.time);
|
|
readString("assets", out.assets);
|
|
|
|
if (root.contains("minimumLauncherVersion"))
|
|
{
|
|
out.minimumLauncherVersion = ensureInteger(root.value("minimumLauncherVersion"));
|
|
}
|
|
|
|
if (root.contains("tweakers"))
|
|
{
|
|
out.shouldOverwriteTweakers = true;
|
|
for (auto tweakerVal : ensureArray(root.value("tweakers")))
|
|
{
|
|
out.overwriteTweakers.append(ensureString(tweakerVal));
|
|
}
|
|
}
|
|
|
|
if (root.contains("+tweakers"))
|
|
{
|
|
for (auto tweakerVal : ensureArray(root.value("+tweakers")))
|
|
{
|
|
out.addTweakers.append(ensureString(tweakerVal));
|
|
}
|
|
}
|
|
|
|
if (root.contains("-tweakers"))
|
|
{
|
|
for (auto tweakerVal : ensureArray(root.value("-tweakers")))
|
|
{
|
|
out.removeTweakers.append(ensureString(tweakerVal));
|
|
}
|
|
}
|
|
|
|
if (root.contains("libraries"))
|
|
{
|
|
// FIXME: This should be done when applying.
|
|
out.shouldOverwriteLibs = !isFTB;
|
|
for (auto libVal : ensureArray(root.value("libraries")))
|
|
{
|
|
auto libObj = ensureObject(libVal);
|
|
|
|
RawLibrary lib = RawLibrary::fromJson(libObj, filename);
|
|
// FIXME: This should be done when applying.
|
|
if (isFTB)
|
|
{
|
|
lib.hint = "local";
|
|
lib.insertType = RawLibrary::Prepend;
|
|
out.addLibs.prepend(lib);
|
|
}
|
|
else
|
|
{
|
|
out.overwriteLibs.append(lib);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (root.contains("+libraries"))
|
|
{
|
|
for (auto libVal : ensureArray(root.value("+libraries")))
|
|
{
|
|
QJsonObject libObj = ensureObject(libVal);
|
|
QJsonValue insertVal = ensureExists(libObj.value("insert"));
|
|
|
|
// parse the library
|
|
RawLibrary lib = RawLibrary::fromJson(libObj, filename);
|
|
|
|
// TODO: utility functions for handling this case. templates?
|
|
QString insertString;
|
|
{
|
|
if (insertVal.isString())
|
|
{
|
|
insertString = insertVal.toString();
|
|
}
|
|
else if (insertVal.isObject())
|
|
{
|
|
QJsonObject insertObj = insertVal.toObject();
|
|
if (insertObj.isEmpty())
|
|
{
|
|
throw JSONValidationError("One library has an empty insert object in " +
|
|
filename);
|
|
}
|
|
insertString = insertObj.keys().first();
|
|
lib.insertData = insertObj.value(insertString).toString();
|
|
}
|
|
}
|
|
if (insertString == "apply")
|
|
{
|
|
lib.insertType = RawLibrary::Apply;
|
|
}
|
|
else if (insertString == "prepend")
|
|
{
|
|
lib.insertType = RawLibrary::Prepend;
|
|
}
|
|
else if (insertString == "append")
|
|
{
|
|
lib.insertType = RawLibrary::Prepend;
|
|
}
|
|
else if (insertString == "replace")
|
|
{
|
|
lib.insertType = RawLibrary::Replace;
|
|
}
|
|
else
|
|
{
|
|
throw JSONValidationError("A '+' library in " + filename +
|
|
" contains an invalid insert type");
|
|
}
|
|
if (libObj.contains("MMC-depend"))
|
|
{
|
|
const QString dependString = ensureString(libObj.value("MMC-depend"));
|
|
if (dependString == "hard")
|
|
{
|
|
lib.dependType = RawLibrary::Hard;
|
|
}
|
|
else if (dependString == "soft")
|
|
{
|
|
lib.dependType = RawLibrary::Soft;
|
|
}
|
|
else
|
|
{
|
|
throw JSONValidationError("A '+' library in " + filename +
|
|
" contains an invalid depend type");
|
|
}
|
|
}
|
|
out.addLibs.append(lib);
|
|
}
|
|
}
|
|
if (root.contains("-libraries"))
|
|
{
|
|
for (auto libVal : ensureArray(root.value("-libraries")))
|
|
{
|
|
auto libObj = ensureObject(libVal);
|
|
out.removeLibs.append(ensureString(libObj.value("name")));
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::shared_ptr<OneSixLibrary> VersionFile::createLibrary(const RawLibrary &lib)
|
|
{
|
|
std::shared_ptr<OneSixLibrary> out(new OneSixLibrary(lib.name));
|
|
if (!lib.url.isEmpty())
|
|
{
|
|
out->setBaseUrl(lib.url);
|
|
}
|
|
out->setHint(lib.hint);
|
|
if (!lib.absoluteUrl.isEmpty())
|
|
{
|
|
out->setAbsoluteUrl(lib.absoluteUrl);
|
|
}
|
|
out->setAbsoluteUrl(lib.absoluteUrl);
|
|
out->extract_excludes = lib.excludes;
|
|
for (auto native : lib.natives)
|
|
{
|
|
out->addNative(native.first, native.second);
|
|
}
|
|
out->setRules(lib.rules);
|
|
out->finalize();
|
|
return out;
|
|
}
|
|
|
|
int VersionFile::findLibrary(QList<std::shared_ptr<OneSixLibrary>> haystack,
|
|
const QString &needle)
|
|
{
|
|
for (int i = 0; i < haystack.size(); ++i)
|
|
{
|
|
if (QRegExp(needle, Qt::CaseSensitive, QRegExp::WildcardUnix)
|
|
.indexIn(haystack.at(i)->rawName()) != -1)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void VersionFile::applyTo(VersionFinal *version)
|
|
{
|
|
if (minimumLauncherVersion != -1)
|
|
{
|
|
if (minimumLauncherVersion > CURRENT_MINIMUM_LAUNCHER_VERSION)
|
|
{
|
|
throw VersionBuildError(
|
|
QString("%1 is for a different launcher version (%2), current supported is %3")
|
|
.arg(filename, minimumLauncherVersion, CURRENT_MINIMUM_LAUNCHER_VERSION));
|
|
}
|
|
}
|
|
|
|
if (!version->id.isNull() && !mcVersion.isNull())
|
|
{
|
|
if (QRegExp(mcVersion, Qt::CaseInsensitive, QRegExp::Wildcard).indexIn(version->id) ==
|
|
-1)
|
|
{
|
|
throw VersionBuildError(
|
|
QString("%1 is for a different version of Minecraft").arg(filename));
|
|
}
|
|
}
|
|
|
|
if (!id.isNull())
|
|
{
|
|
version->id = id;
|
|
}
|
|
if (!mainClass.isNull())
|
|
{
|
|
version->mainClass = mainClass;
|
|
}
|
|
if (!processArguments.isNull())
|
|
{
|
|
version->processArguments = processArguments;
|
|
}
|
|
if (!type.isNull())
|
|
{
|
|
version->type = type;
|
|
}
|
|
if (!releaseTime.isNull())
|
|
{
|
|
version->releaseTime = releaseTime;
|
|
}
|
|
if (!time.isNull())
|
|
{
|
|
version->time = time;
|
|
}
|
|
if (!assets.isNull())
|
|
{
|
|
version->assets = assets;
|
|
}
|
|
if (minimumLauncherVersion >= 0)
|
|
{
|
|
version->minimumLauncherVersion = minimumLauncherVersion;
|
|
}
|
|
if (!overwriteMinecraftArguments.isNull())
|
|
{
|
|
version->minecraftArguments = overwriteMinecraftArguments;
|
|
}
|
|
if (!addMinecraftArguments.isNull())
|
|
{
|
|
version->minecraftArguments += addMinecraftArguments;
|
|
}
|
|
if (!removeMinecraftArguments.isNull())
|
|
{
|
|
version->minecraftArguments.remove(removeMinecraftArguments);
|
|
}
|
|
if (shouldOverwriteTweakers)
|
|
{
|
|
version->tweakers = overwriteTweakers;
|
|
}
|
|
for (auto tweaker : addTweakers)
|
|
{
|
|
version->tweakers += tweaker;
|
|
}
|
|
for (auto tweaker : removeTweakers)
|
|
{
|
|
version->tweakers.removeAll(tweaker);
|
|
}
|
|
if (shouldOverwriteLibs)
|
|
{
|
|
version->libraries.clear();
|
|
for (auto lib : overwriteLibs)
|
|
{
|
|
version->libraries.append(createLibrary(lib));
|
|
}
|
|
}
|
|
for (auto lib : addLibs)
|
|
{
|
|
switch (lib.insertType)
|
|
{
|
|
case RawLibrary::Apply:
|
|
{
|
|
|
|
int index = findLibrary(version->libraries, lib.name);
|
|
if (index >= 0)
|
|
{
|
|
auto library = version->libraries[index];
|
|
if (!lib.url.isNull())
|
|
{
|
|
library->setBaseUrl(lib.url);
|
|
}
|
|
if (!lib.hint.isNull())
|
|
{
|
|
library->setHint(lib.hint);
|
|
}
|
|
if (!lib.absoluteUrl.isNull())
|
|
{
|
|
library->setAbsoluteUrl(lib.absoluteUrl);
|
|
}
|
|
if (lib.applyExcludes)
|
|
{
|
|
library->extract_excludes = lib.excludes;
|
|
}
|
|
if (lib.applyNatives)
|
|
{
|
|
library->clearSuffixes();
|
|
for (auto native : lib.natives)
|
|
{
|
|
library->addNative(native.first, native.second);
|
|
}
|
|
}
|
|
if (lib.applyRules)
|
|
{
|
|
library->setRules(lib.rules);
|
|
}
|
|
library->finalize();
|
|
}
|
|
else
|
|
{
|
|
QLOG_WARN() << "Couldn't find" << lib.name << "(skipping)";
|
|
}
|
|
break;
|
|
}
|
|
case RawLibrary::Append:
|
|
case RawLibrary::Prepend:
|
|
{
|
|
|
|
const int startOfVersion = lib.name.lastIndexOf(':') + 1;
|
|
const int index = findLibrary(
|
|
version->libraries, QString(lib.name).replace(startOfVersion, INT_MAX, '*'));
|
|
if (index < 0)
|
|
{
|
|
if (lib.insertType == RawLibrary::Append)
|
|
{
|
|
version->libraries.append(createLibrary(lib));
|
|
}
|
|
else
|
|
{
|
|
version->libraries.prepend(createLibrary(lib));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto otherLib = version->libraries.at(index);
|
|
const Util::Version ourVersion = lib.name.mid(startOfVersion, INT_MAX);
|
|
const Util::Version otherVersion = otherLib->version();
|
|
// if the existing version is a hard dependency we can either use it or
|
|
// fail, but we can't change it
|
|
if (otherLib->dependType == OneSixLibrary::Hard)
|
|
{
|
|
// we need a higher version, or we're hard to and the versions aren't
|
|
// equal
|
|
if (ourVersion > otherVersion ||
|
|
(lib.dependType == RawLibrary::Hard && ourVersion != otherVersion))
|
|
{
|
|
throw VersionBuildError(
|
|
QString(
|
|
"Error resolving library dependencies between %1 and %2 in %3.")
|
|
.arg(otherLib->rawName(), lib.name, filename));
|
|
}
|
|
else
|
|
{
|
|
// the library is already existing, so we don't have to do anything
|
|
}
|
|
}
|
|
else if (otherLib->dependType == OneSixLibrary::Soft)
|
|
{
|
|
// if we are higher it means we should update
|
|
if (ourVersion > otherVersion)
|
|
{
|
|
auto library = createLibrary(lib);
|
|
if (Util::Version(otherLib->minVersion) < ourVersion)
|
|
{
|
|
library->minVersion = ourVersion.toString();
|
|
}
|
|
version->libraries.replace(index, library);
|
|
}
|
|
else
|
|
{
|
|
// our version is smaller than the existing version, but we require
|
|
// it: fail
|
|
if (lib.dependType == RawLibrary::Hard)
|
|
{
|
|
throw VersionBuildError(QString(
|
|
"Error resolving library dependencies between %1 and %2 in %3.")
|
|
.arg(otherLib->rawName(), lib.name,
|
|
filename));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case RawLibrary::Replace:
|
|
{
|
|
int index = findLibrary(version->libraries, lib.insertData);
|
|
if (index >= 0)
|
|
{
|
|
version->libraries.replace(index, createLibrary(lib));
|
|
}
|
|
else
|
|
{
|
|
QLOG_WARN() << "Couldn't find" << lib.insertData << "(skipping)";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (auto lib : removeLibs)
|
|
{
|
|
int index = findLibrary(version->libraries, lib);
|
|
if (index >= 0)
|
|
{
|
|
version->libraries.removeAt(index);
|
|
}
|
|
else
|
|
{
|
|
QLOG_WARN() << "Couldn't find" << lib << "(skipping)";
|
|
}
|
|
}
|
|
|
|
VersionFinal::VersionFile versionFile;
|
|
versionFile.name = name;
|
|
versionFile.id = fileId;
|
|
versionFile.version = this->version;
|
|
versionFile.mcVersion = mcVersion;
|
|
versionFile.filename = filename;
|
|
versionFile.order = order;
|
|
version->versionFiles.append(versionFile);
|
|
}
|