21 files changed, 1884 insertions, 0 deletions
diff --git a/api/logic/meta/BaseEntity.cpp b/api/logic/meta/BaseEntity.cpp
new file mode 100644
index 00000000..fd44e29c
--- /dev/null
+++ b/api/logic/meta/BaseEntity.cpp
@@ -0,0 +1,42 @@
+/* Copyright 2015-2017 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 "BaseEntity.h"
+
+#include "Json.h"
+#include "Util.h"
+
+namespace Meta
+{
+BaseEntity::~BaseEntity()
+{
+}
+
+void BaseEntity::store() const
+{
+	Json::write(serialized(), Meta::localDir().absoluteFilePath(localFilename()));
+}
+
+void BaseEntity::notifyLocalLoadComplete()
+{
+	m_localLoaded = true;
+	store();
+}
+void BaseEntity::notifyRemoteLoadComplete()
+{
+	m_remoteLoaded = true;
+	store();
+}
+}
diff --git a/api/logic/meta/BaseEntity.h b/api/logic/meta/BaseEntity.h
new file mode 100644
index 00000000..b7a241c6
--- /dev/null
+++ b/api/logic/meta/BaseEntity.h
@@ -0,0 +1,53 @@
+/* Copyright 2015-2017 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 <memory>
+
+#include "multimc_logic_export.h"
+
+class Task;
+namespace Meta
+{
+class MULTIMC_LOGIC_EXPORT BaseEntity
+{
+public:
+	virtual ~BaseEntity();
+
+	using Ptr = std::shared_ptr<BaseEntity>;
+
+	virtual std::unique_ptr<Task> remoteUpdateTask() = 0;
+	virtual std::unique_ptr<Task> localUpdateTask() = 0;
+	virtual void merge(const std::shared_ptr<BaseEntity> &other) = 0;
+
+	void store() const;
+	virtual QString localFilename() const = 0;
+	virtual QJsonObject serialized() const = 0;
+
+	bool isComplete() const { return m_localLoaded || m_remoteLoaded; }
+
+	bool isLocalLoaded() const { return m_localLoaded; }
+	bool isRemoteLoaded() const { return m_remoteLoaded; }
+
+	void notifyLocalLoadComplete();
+	void notifyRemoteLoadComplete();
+
+private:
+	bool m_localLoaded = false;
+	bool m_remoteLoaded = false;
+};
+}
diff --git a/api/logic/meta/Index.cpp b/api/logic/meta/Index.cpp
new file mode 100644
index 00000000..8a6b1355
--- /dev/null
+++ b/api/logic/meta/Index.cpp
@@ -0,0 +1,150 @@
+/* Copyright 2015-2017 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 "Index.h"
+
+#include "VersionList.h"
+#include "tasks/LocalLoadTask.h"
+#include "tasks/RemoteLoadTask.h"
+#include "format/Format.h"
+
+namespace Meta
+{
+Index::Index(QObject *parent)
+	: QAbstractListModel(parent)
+{
+}
+Index::Index(const QVector<VersionListPtr> &lists, QObject *parent)
+	: QAbstractListModel(parent), m_lists(lists)
+{
+	for (int i = 0; i < m_lists.size(); ++i)
+	{
+		m_uids.insert(m_lists.at(i)->uid(), m_lists.at(i));
+		connectVersionList(i, m_lists.at(i));
+	}
+}
+
+QVariant Index::data(const QModelIndex &index, int role) const
+{
+	if (index.parent().isValid() || index.row() < 0 || index.row() >= m_lists.size())
+	{
+		return QVariant();
+	}
+
+	VersionListPtr list = m_lists.at(index.row());
+	switch (role)
+	{
+	case Qt::DisplayRole:
+		switch (index.column())
+		{
+		case 0: return list->humanReadable();
+		default: break;
+		}
+	case UidRole: return list->uid();
+	case NameRole: return list->name();
+	case ListPtrRole: return QVariant::fromValue(list);
+	}
+	return QVariant();
+}
+int Index::rowCount(const QModelIndex &parent) const
+{
+	return m_lists.size();
+}
+int Index::columnCount(const QModelIndex &parent) const
+{
+	return 1;
+}
+QVariant Index::headerData(int section, Qt::Orientation orientation, int role) const
+{
+	if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section == 0)
+	{
+		return tr("Name");
+	}
+	else
+	{
+		return QVariant();
+	}
+}
+
+std::unique_ptr<Task> Index::remoteUpdateTask()
+{
+	return std::unique_ptr<IndexRemoteLoadTask>(new IndexRemoteLoadTask(this, this));
+}
+std::unique_ptr<Task> Index::localUpdateTask()
+{
+	return std::unique_ptr<IndexLocalLoadTask>(new IndexLocalLoadTask(this, this));
+}
+
+QJsonObject Index::serialized() const
+{
+	return Format::serializeIndex(this);
+}
+
+bool Index::hasUid(const QString &uid) const
+{
+	return m_uids.contains(uid);
+}
+VersionListPtr Index::getList(const QString &uid) const
+{
+	return m_uids.value(uid, nullptr);
+}
+VersionListPtr Index::getListGuaranteed(const QString &uid) const
+{
+	return m_uids.value(uid, std::make_shared<VersionList>(uid));
+}
+
+void Index::merge(const Ptr &other)
+{
+	const QVector<VersionListPtr> lists = std::dynamic_pointer_cast<Index>(other)->m_lists;
+	// initial load, no need to merge
+	if (m_lists.isEmpty())
+	{
+		beginResetModel();
+		m_lists = lists;
+		for (int i = 0; i < lists.size(); ++i)
+		{
+			m_uids.insert(lists.at(i)->uid(), lists.at(i));
+			connectVersionList(i, lists.at(i));
+		}
+		endResetModel();
+	}
+	else
+	{
+		for (const VersionListPtr &list : lists)
+		{
+			if (m_uids.contains(list->uid()))
+			{
+				m_uids[list->uid()]->merge(list);
+			}
+			else
+			{
+				beginInsertRows(QModelIndex(), m_lists.size(), m_lists.size());
+				connectVersionList(m_lists.size(), list);
+				m_lists.append(list);
+				m_uids.insert(list->uid(), list);
+				endInsertRows();
+			}
+		}
+	}
+}
+
+void Index::connectVersionList(const int row, const VersionListPtr &list)
+{
+	connect(list.get(), &VersionList::nameChanged, this, [this, row]()
+	{
+		emit dataChanged(index(row), index(row), QVector<int>() << Qt::DisplayRole);
+	});
+}
+}
diff --git a/api/logic/meta/Index.h b/api/logic/meta/Index.h
new file mode 100644
index 00000000..16e95d5a
--- /dev/null
+++ b/api/logic/meta/Index.h
@@ -0,0 +1,72 @@
+/* Copyright 2015-2017 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 <QAbstractListModel>
+#include <memory>
+
+#include "BaseEntity.h"
+
+#include "multimc_logic_export.h"
+
+class Task;
+
+namespace Meta
+{
+using VersionListPtr = std::shared_ptr<class VersionList>;
+
+class MULTIMC_LOGIC_EXPORT Index : public QAbstractListModel, public BaseEntity
+{
+	Q_OBJECT
+public:
+	explicit Index(QObject *parent = nullptr);
+	explicit Index(const QVector<VersionListPtr> &lists, QObject *parent = nullptr);
+
+	enum
+	{
+		UidRole = Qt::UserRole,
+		NameRole,
+		ListPtrRole
+	};
+
+	QVariant data(const QModelIndex &index, int role) const override;
+	int rowCount(const QModelIndex &parent) const override;
+	int columnCount(const QModelIndex &parent) const override;
+	QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
+
+	std::unique_ptr<Task> remoteUpdateTask() override;
+	std::unique_ptr<Task> localUpdateTask() override;
+
+	QString localFilename() const override { return "index.json"; }
+	QJsonObject serialized() const override;
+
+	// queries
+	bool hasUid(const QString &uid) const;
+	VersionListPtr getList(const QString &uid) const;
+	VersionListPtr getListGuaranteed(const QString &uid) const;
+
+	QVector<VersionListPtr> lists() const { return m_lists; }
+
+public: // for usage by parsers only
+	void merge(const BaseEntity::Ptr &other) override;
+
+private:
+	QVector<VersionListPtr> m_lists;
+	QHash<QString, VersionListPtr> m_uids;
+
+	void connectVersionList(const int row, const VersionListPtr &list);
+};
+}
diff --git a/api/logic/meta/Index_test.cpp b/api/logic/meta/Index_test.cpp
new file mode 100644
index 00000000..d26700ca
--- /dev/null
+++ b/api/logic/meta/Index_test.cpp
@@ -0,0 +1,50 @@
+#include <QTest>
+#include "TestUtil.h"
+
+#include "meta/Index.h"
+#include "meta/VersionList.h"
+#include "Env.h"
+
+class IndexTest : public QObject
+{
+	Q_OBJECT
+private
+slots:
+	void test_isProvidedByEnv()
+	{
+		QVERIFY(ENV.metadataIndex());
+		QCOMPARE(ENV.metadataIndex(), ENV.metadataIndex());
+	}
+
+	void test_providesTasks()
+	{
+		QVERIFY(ENV.metadataIndex()->localUpdateTask() != nullptr);
+		QVERIFY(ENV.metadataIndex()->remoteUpdateTask() != nullptr);
+	}
+
+	void test_hasUid_and_getList()
+	{
+		Meta::Index windex({std::make_shared<Meta::VersionList>("list1"), std::make_shared<Meta::VersionList>("list2"), std::make_shared<Meta::VersionList>("list3")});
+		QVERIFY(windex.hasUid("list1"));
+		QVERIFY(!windex.hasUid("asdf"));
+		QVERIFY(windex.getList("list2") != nullptr);
+		QCOMPARE(windex.getList("list2")->uid(), QString("list2"));
+		QVERIFY(windex.getList("adsf") == nullptr);
+	}
+
+	void test_merge()
+	{
+		Meta::Index windex({std::make_shared<Meta::VersionList>("list1"), std::make_shared<Meta::VersionList>("list2"), std::make_shared<Meta::VersionList>("list3")});
+		QCOMPARE(windex.lists().size(), 3);
+		windex.merge(std::shared_ptr<Meta::Index>(new Meta::Index({std::make_shared<Meta::VersionList>("list1"), std::make_shared<Meta::VersionList>("list2"), std::make_shared<Meta::VersionList>("list3")})));
+		QCOMPARE(windex.lists().size(), 3);
+		windex.merge(std::shared_ptr<Meta::Index>(new Meta::Index({std::make_shared<Meta::VersionList>("list4"), std::make_shared<Meta::VersionList>("list2"), std::make_shared<Meta::VersionList>("list5")})));
+		QCOMPARE(windex.lists().size(), 5);
+		windex.merge(std::shared_ptr<Meta::Index>(new Meta::Index({std::make_shared<Meta::VersionList>("list6")})));
+		QCOMPARE(windex.lists().size(), 6);
+	}
+};
+
+QTEST_GUILESS_MAIN(IndexTest)
+
+#include "Index_test.moc"
diff --git a/api/logic/meta/Reference.cpp b/api/logic/meta/Reference.cpp
new file mode 100644
index 00000000..c5cef172
--- /dev/null
+++ b/api/logic/meta/Reference.cpp
@@ -0,0 +1,48 @@
+/* Copyright 2015-2017 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 "Reference.h"
+
+namespace Meta
+{
+Reference::Reference(const QString &uid)
+	: m_uid(uid)
+{
+}
+
+QString Reference::uid() const
+{
+	return m_uid;
+}
+
+QString Reference::version() const
+{
+	return m_version;
+}
+void Reference::setVersion(const QString &version)
+{
+	m_version = version;
+}
+
+bool Reference::operator==(const Reference &other) const
+{
+	return m_uid == other.m_uid && m_version == other.m_version;
+}
+
+bool Reference::operator!=(const Reference &other) const
+{
+	return m_uid != other.m_uid || m_version != other.m_version;
+}
+}
diff --git a/api/logic/meta/Reference.h b/api/logic/meta/Reference.h
new file mode 100644
index 00000000..027076cc
--- /dev/null
+++ b/api/logic/meta/Reference.h
@@ -0,0 +1,44 @@
+/* Copyright 2015-2017 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 <QMetaType>
+
+#include "multimc_logic_export.h"
+
+namespace Meta
+{
+class MULTIMC_LOGIC_EXPORT Reference
+{
+public:
+	Reference() {}
+	explicit Reference(const QString &uid);
+
+	QString uid() const;
+
+	QString version() const;
+	void setVersion(const QString &version);
+
+	bool operator==(const Reference &other) const;
+	bool operator!=(const Reference &other) const;
+
+private:
+	QString m_uid;
+	QString m_version;
+};
+}
+Q_DECLARE_METATYPE(Meta::Reference)
diff --git a/api/logic/meta/Util.cpp b/api/logic/meta/Util.cpp
new file mode 100644
index 00000000..2ccbe5c4
--- /dev/null
+++ b/api/logic/meta/Util.cpp
@@ -0,0 +1,50 @@
+/* Copyright 2015-2017 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 "Util.h"
+
+#include <QUrl>
+#include <QDir>
+
+#include "Env.h"
+
+namespace Meta
+{
+QUrl rootUrl()
+{
+	return QUrl("https://meta.multimc.org");
+}
+
+QUrl indexUrl()
+{
+	return rootUrl().resolved(QStringLiteral("index.json"));
+}
+
+QUrl versionListUrl(const QString &uid)
+{
+	return rootUrl().resolved(uid + ".json");
+}
+
+QUrl versionUrl(const QString &uid, const QString &version)
+{
+	return rootUrl().resolved(uid + "/" + version + ".json");
+}
+
+QDir localDir()
+{
+	return QDir("meta");
+}
+
+}
diff --git a/api/logic/meta/Util.h b/api/logic/meta/Util.h
new file mode 100644
index 00000000..28163fe4
--- /dev/null
+++ b/api/logic/meta/Util.h
@@ -0,0 +1,31 @@
+/* Copyright 2015-2017 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 "multimc_logic_export.h"
+
+class QUrl;
+class QString;
+class QDir;
+
+namespace Meta
+{
+MULTIMC_LOGIC_EXPORT QUrl rootUrl();
+MULTIMC_LOGIC_EXPORT QUrl indexUrl();
+MULTIMC_LOGIC_EXPORT QUrl versionListUrl(const QString &uid);
+MULTIMC_LOGIC_EXPORT QUrl versionUrl(const QString &uid, const QString &version);
+MULTIMC_LOGIC_EXPORT QDir localDir();
+}
diff --git a/api/logic/meta/Version.cpp b/api/logic/meta/Version.cpp
new file mode 100644
index 00000000..039f4fef
--- /dev/null
+++ b/api/logic/meta/Version.cpp
@@ -0,0 +1,105 @@
+/* Copyright 2015-2017 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 "Version.h"
+
+#include <QDateTime>
+
+#include "tasks/LocalLoadTask.h"
+#include "tasks/RemoteLoadTask.h"
+#include "format/Format.h"
+
+namespace Meta
+{
+Version::Version(const QString &uid, const QString &version)
+	: BaseVersion(), m_uid(uid), m_version(version)
+{
+}
+
+QString Version::descriptor()
+{
+	return m_version;
+}
+QString Version::name()
+{
+	return m_version;
+}
+QString Version::typeString() const
+{
+	return m_type;
+}
+
+QDateTime Version::time() const
+{
+	return QDateTime::fromMSecsSinceEpoch(m_time * 1000, Qt::UTC);
+}
+
+std::unique_ptr<Task> Version::remoteUpdateTask()
+{
+	return std::unique_ptr<VersionRemoteLoadTask>(new VersionRemoteLoadTask(this, this));
+}
+std::unique_ptr<Task> Version::localUpdateTask()
+{
+	return std::unique_ptr<VersionLocalLoadTask>(new VersionLocalLoadTask(this, this));
+}
+
+void Version::merge(const std::shared_ptr<BaseEntity> &other)
+{
+	VersionPtr version = std::dynamic_pointer_cast<Version>(other);
+	if (m_type != version->m_type)
+	{
+		setType(version->m_type);
+	}
+	if (m_time != version->m_time)
+	{
+		setTime(version->m_time);
+	}
+	if (m_requires != version->m_requires)
+	{
+		setRequires(version->m_requires);
+	}
+
+	setData(version->m_data);
+}
+
+QString Version::localFilename() const
+{
+	return m_uid + '/' + m_version + ".json";
+}
+QJsonObject Version::serialized() const
+{
+	return Format::serializeVersion(this);
+}
+
+void Version::setType(const QString &type)
+{
+	m_type = type;
+	emit typeChanged();
+}
+void Version::setTime(const qint64 time)
+{
+	m_time = time;
+	emit timeChanged();
+}
+void Version::setRequires(const QVector<Reference> &requires)
+{
+	m_requires = requires;
+	emit requiresChanged();
+}
+void Version::setData(const VersionFilePtr &data)
+{
+	m_data = data;
+}
+}
diff --git a/api/logic/meta/Version.h b/api/logic/meta/Version.h
new file mode 100644
index 00000000..4a791880
--- /dev/null
+++ b/api/logic/meta/Version.h
@@ -0,0 +1,87 @@
+/* Copyright 2015-2017 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 "BaseVersion.h"
+
+#include <QVector>
+#include <QStringList>
+#include <QJsonObject>
+#include <memory>
+
+#include "minecraft/VersionFile.h"
+
+#include "BaseEntity.h"
+#include "Reference.h"
+
+#include "multimc_logic_export.h"
+
+namespace Meta
+{
+using VersionPtr = std::shared_ptr<class Version>;
+
+class MULTIMC_LOGIC_EXPORT Version : public QObject, public BaseVersion, public BaseEntity
+{
+	Q_OBJECT
+	Q_PROPERTY(QString uid READ uid CONSTANT)
+	Q_PROPERTY(QString version READ version CONSTANT)
+	Q_PROPERTY(QString type READ type NOTIFY typeChanged)
+	Q_PROPERTY(QDateTime time READ time NOTIFY timeChanged)
+	Q_PROPERTY(QVector<Reference> requires READ requires NOTIFY requiresChanged)
+public:
+	explicit Version(const QString &uid, const QString &version);
+
+	QString descriptor() override;
+	QString name() override;
+	QString typeString() const override;
+
+	QString uid() const { return m_uid; }
+	QString version() const { return m_version; }
+	QString type() const { return m_type; }
+	QDateTime time() const;
+	qint64 rawTime() const { return m_time; }
+	QVector<Reference> requires() const { return m_requires; }
+	VersionFilePtr data() const { return m_data; }
+
+	std::unique_ptr<Task> remoteUpdateTask() override;
+	std::unique_ptr<Task> localUpdateTask() override;
+	void merge(const std::shared_ptr<BaseEntity> &other) override;
+
+	QString localFilename() const override;
+	QJsonObject serialized() const override;
+
+public: // for usage by format parsers only
+	void setType(const QString &type);
+	void setTime(const qint64 time);
+	void setRequires(const QVector<Reference> &requires);
+	void setData(const VersionFilePtr &data);
+
+signals:
+	void typeChanged();
+	void timeChanged();
+	void requiresChanged();
+
+private:
+	QString m_uid;
+	QString m_version;
+	QString m_type;
+	qint64 m_time;
+	QVector<Reference> m_requires;
+	VersionFilePtr m_data;
+};
+}
+
+Q_DECLARE_METATYPE(Meta::VersionPtr)
diff --git a/api/logic/meta/VersionList.cpp b/api/logic/meta/VersionList.cpp
new file mode 100644
index 00000000..11e20c12
--- /dev/null
+++ b/api/logic/meta/VersionList.cpp
@@ -0,0 +1,288 @@
+/* Copyright 2015-2017 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 "VersionList.h"
+
+#include <QDateTime>
+
+#include "Version.h"
+#include "tasks/RemoteLoadTask.h"
+#include "tasks/LocalLoadTask.h"
+#include "format/Format.h"
+#include "Reference.h"
+
+namespace Meta
+{
+
+class WVLLoadTask : public Task
+{
+	Q_OBJECT
+public:
+	explicit WVLLoadTask(VersionList *list, QObject *parent = nullptr)
+		: Task(parent), m_list(list)
+	{
+	}
+
+	bool canAbort() const override
+	{
+		return !m_currentTask || m_currentTask->canAbort();
+	}
+	bool abort() override
+	{
+		return m_currentTask->abort();
+	}
+
+private:
+	void executeTask() override
+	{
+		if (!m_list->isLocalLoaded())
+		{
+			m_currentTask = m_list->localUpdateTask();
+			connect(m_currentTask.get(), &Task::succeeded, this, &WVLLoadTask::next);
+		}
+		else
+		{
+			m_currentTask = m_list->remoteUpdateTask();
+			connect(m_currentTask.get(), &Task::succeeded, this, &WVLLoadTask::emitSucceeded);
+		}
+		connect(m_currentTask.get(), &Task::status, this, &WVLLoadTask::setStatus);
+		connect(m_currentTask.get(), &Task::progress, this, &WVLLoadTask::setProgress);
+		connect(m_currentTask.get(), &Task::failed, this, &WVLLoadTask::emitFailed);
+		m_currentTask->start();
+	}
+
+	void next()
+	{
+		m_currentTask = m_list->remoteUpdateTask();
+		connect(m_currentTask.get(), &Task::status, this, &WVLLoadTask::setStatus);
+		connect(m_currentTask.get(), &Task::progress, this, &WVLLoadTask::setProgress);
+		connect(m_currentTask.get(), &Task::succeeded, this, &WVLLoadTask::emitSucceeded);
+		m_currentTask->start();
+	}
+
+	VersionList *m_list;
+	std::unique_ptr<Task> m_currentTask;
+};
+
+VersionList::VersionList(const QString &uid, QObject *parent)
+	: BaseVersionList(parent), m_uid(uid)
+{
+	setObjectName("Version list: " + uid);
+}
+
+Task *VersionList::getLoadTask()
+{
+	return new WVLLoadTask(this);
+}
+
+bool VersionList::isLoaded()
+{
+	return isLocalLoaded() && isRemoteLoaded();
+}
+
+const BaseVersionPtr VersionList::at(int i) const
+{
+	return m_versions.at(i);
+}
+int VersionList::count() const
+{
+	return m_versions.size();
+}
+
+void VersionList::sortVersions()
+{
+	beginResetModel();
+	std::sort(m_versions.begin(), m_versions.end(), [](const VersionPtr &a, const VersionPtr &b)
+	{
+		return *a.get() < *b.get();
+	});
+	endResetModel();
+}
+
+QVariant VersionList::data(const QModelIndex &index, int role) const
+{
+	if (!index.isValid() || index.row() < 0 || index.row() >= m_versions.size() || index.parent().isValid())
+	{
+		return QVariant();
+	}
+
+	VersionPtr version = m_versions.at(index.row());
+
+	switch (role)
+	{
+	case VersionPointerRole: return QVariant::fromValue(std::dynamic_pointer_cast<BaseVersion>(version));
+	case VersionRole:
+	case VersionIdRole:
+		return version->version();
+	case ParentGameVersionRole:
+	{
+		const auto end = version->requires().end();
+		const auto it = std::find_if(version->requires().begin(), end,
+									 [](const Reference &ref) { return ref.uid() == "net.minecraft"; });
+		if (it != end)
+		{
+			return (*it).version();
+		}
+		return QVariant();
+	}
+	case TypeRole: return version->type();
+
+	case UidRole: return version->uid();
+	case TimeRole: return version->time();
+	case RequiresRole: return QVariant::fromValue(version->requires());
+	case SortRole: return version->rawTime();
+	case VersionPtrRole: return QVariant::fromValue(version);
+	case RecommendedRole: return version == getRecommended();
+	case LatestRole: return version == getLatestStable();
+	default: return QVariant();
+	}
+}
+
+BaseVersionList::RoleList VersionList::providesRoles() const
+{
+	return {VersionPointerRole, VersionRole, VersionIdRole, ParentGameVersionRole,
+				TypeRole, UidRole, TimeRole, RequiresRole, SortRole,
+				RecommendedRole, LatestRole, VersionPtrRole};
+}
+
+QHash<int, QByteArray> VersionList::roleNames() const
+{
+	QHash<int, QByteArray> roles = BaseVersionList::roleNames();
+	roles.insert(UidRole, "uid");
+	roles.insert(TimeRole, "time");
+	roles.insert(SortRole, "sort");
+	roles.insert(RequiresRole, "requires");
+	return roles;
+}
+
+std::unique_ptr<Task> VersionList::remoteUpdateTask()
+{
+	return std::unique_ptr<VersionListRemoteLoadTask>(new VersionListRemoteLoadTask(this, this));
+}
+std::unique_ptr<Task> VersionList::localUpdateTask()
+{
+	return std::unique_ptr<VersionListLocalLoadTask>(new VersionListLocalLoadTask(this, this));
+}
+
+QString VersionList::localFilename() const
+{
+	return m_uid + ".json";
+}
+QJsonObject VersionList::serialized() const
+{
+	return Format::serializeVersionList(this);
+}
+
+QString VersionList::humanReadable() const
+{
+	return m_name.isEmpty() ? m_uid : m_name;
+}
+
+bool VersionList::hasVersion(const QString &version) const
+{
+	return m_lookup.contains(version);
+}
+VersionPtr VersionList::getVersion(const QString &version) const
+{
+	return m_lookup.value(version);
+}
+
+void VersionList::setName(const QString &name)
+{
+	m_name = name;
+	emit nameChanged(name);
+}
+void VersionList::setVersions(const QVector<VersionPtr> &versions)
+{
+	beginResetModel();
+	m_versions = versions;
+	std::sort(m_versions.begin(), m_versions.end(), [](const VersionPtr &a, const VersionPtr &b)
+	{
+		return a->rawTime() > b->rawTime();