NOISSUE reorganize and document libraries

4 files changed, 576 insertions, 0 deletions

diff --git a/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp b/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp
new file mode 100644
index 00000000..25297fa4
--- /dev/null
+++ b/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp
@@ -0,0 +1,142 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LiteLoaderInstaller.h"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+
+#include <QDebug>
+
+#include "minecraft/MinecraftProfile.h"
+#include "minecraft/Library.h"
+#include "minecraft/onesix/OneSixInstance.h"
+#include <minecraft/onesix/OneSixVersionFormat.h>
+#include "minecraft/liteloader/LiteLoaderVersionList.h"
+#include "Exception.h"
+
+LiteLoaderInstaller::LiteLoaderInstaller() : BaseInstaller()
+{
+}
+
+void LiteLoaderInstaller::prepare(LiteLoaderVersionPtr version)
+{
+	m_version = version;
+}
+bool LiteLoaderInstaller::add(OneSixInstance *to)
+{
+	if (!BaseInstaller::add(to))
+	{
+		return false;
+	}
+
+	QJsonObject obj;
+
+	obj.insert("mainClass", QString("net.minecraft.launchwrapper.Launch"));
+	obj.insert("+tweakers", QJsonArray::fromStringList(QStringList() << m_version->tweakClass));
+	obj.insert("order", 10);
+
+	QJsonArray libraries;
+
+	for (auto Library : m_version->libraries)
+	{
+		libraries.append(OneSixVersionFormat::libraryToJson(Library.get()));
+	}
+
+	// liteloader
+	{
+		Library liteloaderLib("com.mumfrey:liteloader:" + m_version->version);
+		liteloaderLib.setAbsoluteUrl(QString("http://dl.liteloader.com/versions/com/mumfrey/liteloader/%1/%2").arg(m_version->mcVersion, m_version->file));
+		QJsonObject llLibObj = OneSixVersionFormat::libraryToJson(&liteloaderLib);
+		libraries.append(llLibObj);
+	}
+
+	obj.insert("+libraries", libraries);
+	obj.insert("name", QString("LiteLoader"));
+	obj.insert("fileId", id());
+	obj.insert("version", m_version->version);
+	obj.insert("mcVersion", to->intendedVersionId());
+
+	QFile file(filename(to->instanceRoot()));
+	if (!file.open(QFile::WriteOnly))
+	{
+		qCritical() << "Error opening" << file.fileName()
+					 << "for reading:" << file.errorString();
+		return false;
+	}
+	file.write(QJsonDocument(obj).toJson());
+	file.close();
+
+	return true;
+}
+
+class LiteLoaderInstallTask : public Task
+{
+	Q_OBJECT
+public:
+	LiteLoaderInstallTask(LiteLoaderInstaller *installer, OneSixInstance *instance,
+						  BaseVersionPtr version, QObject *parent)
+		: Task(parent), m_installer(installer), m_instance(instance), m_version(version)
+	{
+	}
+
+protected:
+	void executeTask() override
+	{
+		LiteLoaderVersionPtr liteloaderVersion =
+			std::dynamic_pointer_cast<LiteLoaderVersion>(m_version);
+		if (!liteloaderVersion)
+		{
+			return;
+		}
+		m_installer->prepare(liteloaderVersion);
+		if (!m_installer->add(m_instance))
+		{
+			emitFailed(tr("For reasons unknown, the LiteLoader installation failed. Check your "
+						  "MultiMC log files for details."));
+		}
+		else
+		{
+			try
+			{
+				m_instance->reloadProfile();
+				emitSucceeded();
+			}
+			catch (Exception &e)
+			{
+				emitFailed(e.cause());
+			}
+			catch (...)
+			{
+				emitFailed(
+					tr("Failed to load the version description file for reasons unknown."));
+			}
+		}
+	}
+
+private:
+	LiteLoaderInstaller *m_installer;
+	OneSixInstance *m_instance;
+	BaseVersionPtr m_version;
+};
+
+Task *LiteLoaderInstaller::createInstallTask(OneSixInstance *instance,
+														 BaseVersionPtr version,
+														 QObject *parent)
+{
+	return new LiteLoaderInstallTask(this, instance, version, parent);
+}
+
+#include "LiteLoaderInstaller.moc"
diff --git a/api/logic/minecraft/liteloader/LiteLoaderInstaller.h b/api/logic/minecraft/liteloader/LiteLoaderInstaller.h
new file mode 100644
index 00000000..fe0aee3d
--- /dev/null
+++ b/api/logic/minecraft/liteloader/LiteLoaderInstaller.h
@@ -0,0 +1,39 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <QString>
+#include <QMap>
+
+#include "BaseInstaller.h"
+#include "LiteLoaderVersionList.h"
+
+#include "multimc_logic_export.h"
+
+class MULTIMC_LOGIC_EXPORT LiteLoaderInstaller : public BaseInstaller
+{
+public:
+	LiteLoaderInstaller();
+
+	void prepare(LiteLoaderVersionPtr version);
+	bool add(OneSixInstance *to) override;
+	virtual QString id() const override { return "com.mumfrey.liteloader"; }
+
+	Task *createInstallTask(OneSixInstance *instance, BaseVersionPtr version, QObject *parent) override;
+
+private:
+	LiteLoaderVersionPtr m_version;
+};
diff --git a/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp b/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp
new file mode 100644
index 00000000..b0c9736a
--- /dev/null
+++ b/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp
@@ -0,0 +1,276 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LiteLoaderVersionList.h"
+#include <minecraft/onesix/OneSixVersionFormat.h>
+#include "Env.h"
+#include "net/URLConstants.h"
+#include "Exception.h"
+
+#include <QtXml>
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+#include <QJsonParseError>
+
+#include <QtAlgorithms>
+
+#include <QtNetwork>
+
+LiteLoaderVersionList::LiteLoaderVersionList(QObject *parent) : BaseVersionList(parent)
+{
+}
+
+Task *LiteLoaderVersionList::getLoadTask()
+{
+	return new LLListLoadTask(this);
+}
+
+bool LiteLoaderVersionList::isLoaded()
+{
+	return m_loaded;
+}
+
+const BaseVersionPtr LiteLoaderVersionList::at(int i) const
+{
+	return m_vlist.at(i);
+}
+
+int LiteLoaderVersionList::count() const
+{
+	return m_vlist.count();
+}
+
+static bool cmpVersions(BaseVersionPtr first, BaseVersionPtr second)
+{
+	auto left = std::dynamic_pointer_cast<LiteLoaderVersion>(first);
+	auto right = std::dynamic_pointer_cast<LiteLoaderVersion>(second);
+	return left->timestamp > right->timestamp;
+}
+
+void LiteLoaderVersionList::sortVersions()
+{
+	beginResetModel();
+	std::sort(m_vlist.begin(), m_vlist.end(), cmpVersions);
+	endResetModel();
+}
+
+QVariant LiteLoaderVersionList::data(const QModelIndex &index, int role) const
+{
+	if (!index.isValid())
+		return QVariant();
+
+	if (index.row() > count())
+		return QVariant();
+
+	auto version = std::dynamic_pointer_cast<LiteLoaderVersion>(m_vlist[index.row()]);
+	switch (role)
+	{
+	case VersionPointerRole:
+		return qVariantFromValue(m_vlist[index.row()]);
+
+	case VersionRole:
+		return version->name();
+
+	case VersionIdRole:
+		return version->descriptor();
+
+	case ParentGameVersionRole:
+		return version->mcVersion;
+
+	case RecommendedRole:
+		return version->isLatest;
+
+	default:
+		return QVariant();
+	}
+}
+
+QList<BaseVersionList::ModelRoles> LiteLoaderVersionList::providesRoles()
+{
+	return {VersionPointerRole, VersionRole, VersionIdRole, ParentGameVersionRole, RecommendedRole};
+}
+
+BaseVersionPtr LiteLoaderVersionList::getLatestStable() const
+{
+	for (int i = 0; i < m_vlist.length(); i++)
+	{
+		auto ver = std::dynamic_pointer_cast<LiteLoaderVersion>(m_vlist.at(i));
+		if (ver->isLatest)
+		{
+			return m_vlist.at(i);
+		}
+	}
+	return BaseVersionPtr();
+}
+
+void LiteLoaderVersionList::updateListData(QList<BaseVersionPtr> versions)
+{
+	beginResetModel();
+	m_vlist = versions;
+	m_loaded = true;
+	std::sort(m_vlist.begin(), m_vlist.end(), cmpVersions);
+	endResetModel();
+}
+
+LLListLoadTask::LLListLoadTask(LiteLoaderVersionList *vlist)
+{
+	m_list = vlist;
+}
+
+LLListLoadTask::~LLListLoadTask()
+{
+}
+
+void LLListLoadTask::executeTask()
+{
+	setStatus(tr("Loading LiteLoader version list..."));
+	auto job = new NetJob("Version index");
+	// we do not care if the version is stale or not.
+	auto liteloaderEntry = ENV.metacache()->resolveEntry("liteloader", "versions.json");
+
+	// verify by poking the server.
+	liteloaderEntry->setStale(true);
+
+	job->addNetAction(listDownload = CacheDownload::make(QUrl(URLConstants::LITELOADER_URL),
+														 liteloaderEntry));
+
+	connect(listDownload.get(), SIGNAL(failed(int)), SLOT(listFailed()));
+
+	listJob.reset(job);
+	connect(listJob.get(), SIGNAL(succeeded()), SLOT(listDownloaded()));
+	connect(listJob.get(), SIGNAL(progress(qint64, qint64)), SIGNAL(progress(qint64, qint64)));
+	listJob->start();
+}
+
+void LLListLoadTask::listFailed()
+{
+	emitFailed("Failed to load LiteLoader version list.");
+	return;
+}
+
+void LLListLoadTask::listDownloaded()
+{
+	QByteArray data;
+	{
+		auto dlJob = listDownload;
+		auto filename = std::dynamic_pointer_cast<CacheDownload>(dlJob)->getTargetFilepath();
+		QFile listFile(filename);
+		if (!listFile.open(QIODevice::ReadOnly))
+		{
+			emitFailed("Failed to open the LiteLoader version list.");
+			return;
+		}
+		data = listFile.readAll();
+		listFile.close();
+		dlJob.reset();
+	}
+
+	QJsonParseError jsonError;
+	QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError);
+
+	if (jsonError.error != QJsonParseError::NoError)
+	{
+		emitFailed("Error parsing version list JSON:" + jsonError.errorString());
+		return;
+	}
+
+	if (!jsonDoc.isObject())
+	{
+		emitFailed("Error parsing version list JSON: jsonDoc is not an object");
+		return;
+	}
+
+	const QJsonObject root = jsonDoc.object();
+
+	// Now, get the array of versions.
+	if (!root.value("versions").isObject())
+	{
+		emitFailed("Error parsing version list JSON: missing 'versions' object");
+		return;
+	}
+
+	auto meta = root.value("meta").toObject();
+	QString description = meta.value("description").toString(tr("This is a lightweight loader for mods that don't change game mechanics."));
+	QString defaultUrl = meta.value("url").toString("http://dl.liteloader.com");
+	QString authors = meta.value("authors").toString("Mumfrey");
+	auto versions = root.value("versions").toObject();
+
+	QList<BaseVersionPtr> tempList;
+	for (auto vIt = versions.begin(); vIt != versions.end(); ++vIt)
+	{
+		const QString mcVersion = vIt.key();
+		QString latest;
+		const QJsonObject artefacts = vIt.value()
+										  .toObject()
+										  .value("artefacts")
+										  .toObject()
+										  .value("com.mumfrey:liteloader")
+										  .toObject();
+		QList<BaseVersionPtr> perMcVersionList;
+		for (auto aIt = artefacts.begin(); aIt != artefacts.end(); ++aIt)
+		{
+			const QString identifier = aIt.key();
+			const QJsonObject artefact = aIt.value().toObject();
+			if (identifier == "latest")
+			{
+				latest = artefact.value("version").toString();
+				continue;
+			}
+			LiteLoaderVersionPtr version(new LiteLoaderVersion());
+			version->version = artefact.value("version").toString();
+			version->file = artefact.value("file").toString();
+			version->mcVersion = mcVersion;
+			version->md5 = artefact.value("md5").toString();
+			version->timestamp = artefact.value("timestamp").toString().toInt();
+			version->tweakClass = artefact.value("tweakClass").toString();
+			version->authors = authors;
+			version->description = description;
+			version->defaultUrl = defaultUrl;
+			const QJsonArray libs = artefact.value("libraries").toArray();
+			for (auto lIt = libs.begin(); lIt != libs.end(); ++lIt)
+			{
+				auto libobject = (*lIt).toObject();
+				try
+				{
+					auto lib = OneSixVersionFormat::libraryFromJson(libobject, "versions.json");
+					// hack to make liteloader 1.7.10_00 work
+					if(lib->rawName() == GradleSpecifier("org.ow2.asm:asm-all:5.0.3"))
+					{
+						lib->setRepositoryURL("http://repo.maven.apache.org/maven2/");
+					}
+					version->libraries.append(lib);
+				}
+				catch (Exception &e)
+				{
+					qCritical() << "Couldn't read JSON object:";
+					continue;
+				}
+			}
+			perMcVersionList.append(version);
+		}
+		for (auto version : perMcVersionList)
+		{
+			auto v = std::dynamic_pointer_cast<LiteLoaderVersion>(version);
+			v->isLatest = v->version == latest;
+		}
+		tempList.append(perMcVersionList);
+	}
+	m_list->updateListData(tempList);
+
+	emitSucceeded();
+}
diff --git a/api/logic/minecraft/liteloader/LiteLoaderVersionList.h b/api/logic/minecraft/liteloader/LiteLoaderVersionList.h
new file mode 100644
index 00000000..1dba4b6a
--- /dev/null
+++ b/api/logic/minecraft/liteloader/LiteLoaderVersionList.h
@@ -0,0 +1,119 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include <QString>
+#include <QStringList>
+#include "BaseVersion.h"
+#include "BaseVersionList.h"
+#include "tasks/Task.h"
+#include "net/NetJob.h"
+#include <minecraft/Library.h>
+
+#include "multimc_logic_export.h"
+
+class LLListLoadTask;
+class QNetworkReply;
+
+class LiteLoaderVersion : public BaseVersion
+{
+public:
+	QString descriptor() override
+	{
+		if (isLatest)
+		{
+			return QObject::tr("Latest");
+		}
+		return QString();
+	}
+	QString typeString() const override
+	{
+		return mcVersion;
+	}
+	QString name() override
+	{
+		return version;
+	}
+
+	// important info
+	QString version;
+	QString file;
+	QString mcVersion;
+	QString md5;
+	int timestamp;
+	bool isLatest;
+	QString tweakClass;
+	QList<LibraryPtr> libraries;
+
+	// meta
+	QString defaultUrl;
+	QString description;
+	QString authors;
+};
+typedef std::shared_ptr<LiteLoaderVersion> LiteLoaderVersionPtr;
+
+class MULTIMC_LOGIC_EXPORT LiteLoaderVersionList : public BaseVersionList
+{
+	Q_OBJECT
+public:
+	friend class LLListLoadTask;
+
+	explicit LiteLoaderVersionList(QObject *parent = 0);
+
+	virtual Task *getLoadTask();
+	virtual bool isLoaded();
+	virtual const BaseVersionPtr at(int i) const;
+	virtual int count() const;
+	virtual void sortVersions();
+    virtual QVariant data ( const QModelIndex & index, int role = Qt::DisplayRole ) const;
+    virtual QList< ModelRoles > providesRoles();
+
+	virtual BaseVersionPtr getLatestStable() const;
+
+protected:
+	QList<BaseVersionPtr> m_vlist;
+
+	bool m_loaded = false;
+
+protected
+slots:
+	virtual void updateListData(QList<BaseVersionPtr> versions);
+};
+
+class LLListLoadTask : public Task
+{
+	Q_OBJECT
+
+public:
+	explicit LLListLoadTask(LiteLoaderVersionList *vlist);
+	~LLListLoadTask();
+
+	virtual void executeTask();
+
+protected
+slots:
+	void listDownloaded();
+	void listFailed();
+
+protected:
+	NetJobPtr listJob;
+	CacheDownloadPtr listDownload;
+	LiteLoaderVersionList *m_list;
+};
+
+Q_DECLARE_METATYPE(LiteLoaderVersionPtr)