sneedmc/logic/minecraft/RawLibrary.cpp
2016-01-07 06:40:26 +01:00

324 lines
7.3 KiB
C++

#include "Json.h"
using namespace Json;
#include "RawLibrary.h"
#include <FileSystem.h>
RawLibraryPtr RawLibrary::fromJson(const QJsonObject &libObj, const QString &filename)
{
RawLibraryPtr out(new RawLibrary());
if (!libObj.contains("name"))
{
throw JSONValidationError(filename +
"contains a library that doesn't have a 'name' field");
}
out->m_name = libObj.value("name").toString();
auto readString = [libObj, filename](const QString & key, QString & variable) -> bool
{
if (!libObj.contains(key))
return false;
QJsonValue val = libObj.value(key);
if (!val.isString())
{
qWarning() << key << "is not a string in" << filename << "(skipping)";
return false;
}
variable = val.toString();
return true;
};
QString urlStr;
readString("url", urlStr);
out->m_base_url = urlStr;
readString("MMC-hint", out->m_hint);
readString("MMC-absulute_url", out->m_absolute_url);
readString("MMC-absoluteUrl", out->m_absolute_url);
if (libObj.contains("extract"))
{
out->applyExcludes = true;
auto extractObj = requireObject(libObj.value("extract"));
for (auto excludeVal : requireArray(extractObj.value("exclude")))
{
out->extract_excludes.append(requireString(excludeVal));
}
}
if (libObj.contains("natives"))
{
QJsonObject nativesObj = requireObject(libObj.value("natives"));
for (auto it = nativesObj.begin(); it != nativesObj.end(); ++it)
{
if (!it.value().isString())
{
qWarning() << filename << "contains an invalid native (skipping)";
}
OpSys opSys = OpSys_fromString(it.key());
if (opSys != Os_Other)
{
out->m_native_classifiers[opSys] = it.value().toString();
}
}
}
if (libObj.contains("rules"))
{
out->applyRules = true;
out->m_rules = rulesFromJsonV4(libObj);
}
return out;
}
RawLibraryPtr RawLibrary::fromJsonPlus(const QJsonObject &libObj, const QString &filename)
{
auto lib = RawLibrary::fromJson(libObj, filename);
if (libObj.contains("insert"))
{
QJsonValue insertVal = ensureJsonValue(libObj.value("insert"), QString("library insert rule"));
if (insertVal.isString())
{
// it's just a simple string rule. OK.
QString insertString = insertVal.toString();
if (insertString == "apply")
{
lib->insertType = RawLibrary::Apply;
}
else if (insertString == "prepend")
{
lib->insertType = RawLibrary::Prepend;
}
else if (insertString == "append")
{
lib->insertType = RawLibrary::Append;
}
else if (insertString == "replace")
{
lib->insertType = RawLibrary::Replace;
}
else
{
throw JSONValidationError("A '+' library in " + filename +
" contains an invalid insert type");
}
}
else if (insertVal.isObject())
{
// it's a more complex rule, specifying what should be:
// * replaced (for now only this)
// this was never used, AFAIK. tread carefully.
QJsonObject insertObj = insertVal.toObject();
if (insertObj.isEmpty())
{
throw JSONValidationError("Empty compound insert rule in " + filename);
}
QString insertString = insertObj.keys().first();
// really, only replace makes sense in combination with
if(insertString != "replace")
{
throw JSONValidationError("Compound insert rule is not 'replace' in " + filename);
}
lib->insertData = insertObj.value(insertString).toString();
}
else
{
throw JSONValidationError("A '+' library in " + filename +
" contains an unknown/invalid insert rule");
}
}
if (libObj.contains("MMC-depend"))
{
const QString dependString = requireString(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");
}
}
return lib;
}
QJsonObject RawLibrary::toJson() const
{
QJsonObject libRoot;
libRoot.insert("name", (QString)m_name);
if (m_absolute_url.size())
libRoot.insert("MMC-absoluteUrl", m_absolute_url);
if (m_hint.size())
libRoot.insert("MMC-hint", m_hint);
if (m_base_url != "http://" + URLConstants::AWS_DOWNLOAD_LIBRARIES &&
m_base_url != "https://" + URLConstants::AWS_DOWNLOAD_LIBRARIES &&
m_base_url != "https://" + URLConstants::LIBRARY_BASE && !m_base_url.isEmpty())
{
libRoot.insert("url", m_base_url);
}
if (isNative())
{
QJsonObject nativeList;
auto iter = m_native_classifiers.begin();
while (iter != m_native_classifiers.end())
{
nativeList.insert(OpSys_toString(iter.key()), iter.value());
iter++;
}
libRoot.insert("natives", nativeList);
if (extract_excludes.size())
{
QJsonArray excludes;
QJsonObject extract;
for (auto exclude : extract_excludes)
{
excludes.append(exclude);
}
extract.insert("exclude", excludes);
libRoot.insert("extract", extract);
}
}
if (m_rules.size())
{
QJsonArray allRules;
for (auto &rule : m_rules)
{
QJsonObject ruleObj = rule->toJson();
allRules.append(ruleObj);
}
libRoot.insert("rules", allRules);
}
return libRoot;
}
QStringList RawLibrary::files() const
{
QStringList retval;
QString storage = storageSuffix();
if (storage.contains("${arch}"))
{
QString cooked_storage = storage;
cooked_storage.replace("${arch}", "32");
retval.append(cooked_storage);
cooked_storage = storage;
cooked_storage.replace("${arch}", "64");
retval.append(cooked_storage);
}
else
retval.append(storage);
return retval;
}
bool RawLibrary::filesExist(const QDir &base) const
{
auto libFiles = files();
for(auto file: libFiles)
{
QFileInfo info(base, file);
qWarning() << info.absoluteFilePath() << "doesn't exist";
if (!info.exists())
return false;
}
return true;
}
QString RawLibrary::url() const
{
if (!m_absolute_url.isEmpty())
{
return m_absolute_url;
}
if (m_base_url.isEmpty())
{
return QString("https://" + URLConstants::LIBRARY_BASE) + storageSuffix();
}
if(m_base_url.endsWith('/'))
{
return m_base_url + storageSuffix();
}
else
{
return m_base_url + QChar('/') + storageSuffix();
}
}
bool RawLibrary::isActive() const
{
bool result = true;
if (m_rules.empty())
{
result = true;
}
else
{
RuleAction ruleResult = Disallow;
for (auto rule : m_rules)
{
RuleAction temp = rule->apply(this);
if (temp != Defer)
ruleResult = temp;
}
result = result && (ruleResult == Allow);
}
if (isNative())
{
result = result && m_native_classifiers.contains(currentSystem);
}
return result;
}
void RawLibrary::setStoragePrefix(QString prefix)
{
m_storagePrefix = prefix;
}
QString RawLibrary::defaultStoragePrefix()
{
return "libraries/";
}
QString RawLibrary::storagePrefix() const
{
if(m_storagePrefix.isEmpty())
{
return defaultStoragePrefix();
}
return m_storagePrefix;
}
QString RawLibrary::storageSuffix() const
{
// non-native? use only the gradle specifier
if (!isNative())
{
return m_name.toPath();
}
// otherwise native, override classifiers. Mojang HACK!
GradleSpecifier nativeSpec = m_name;
if (m_native_classifiers.contains(currentSystem))
{
nativeSpec.setClassifier(m_native_classifiers[currentSystem]);
}
else
{
nativeSpec.setClassifier("INVALID");
}
return nativeSpec.toPath();
}
QString RawLibrary::storagePath() const
{
return FS::PathCombine(storagePrefix(), storageSuffix());
}
bool RawLibrary::storagePathIsDefault() const
{
return m_storagePrefix.isEmpty();
}