feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Meson: Start simplification of tool loading

Browse Source 
Change-Id: I5a70c17bd219dc8dc18061842808166b76b26828
Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
This commit is contained in:
hjk
2024-07-22 17:14:09 +02:00
parent c76025ed41
commit 36a6fa1664
8 changed files with 102 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
src/plugins/mesonprojectmanager/mesontools.cpp
View File

@@ -3,6 +3,10 @@
#include "mesontools.h"
#include <utils/environment.h>
using namespace Utils;
namespace MesonProjectManager {
namespace Internal {
@@ -26,27 +30,34 @@ std::shared_ptr<T> tool(const Utils::Id &id, const std::vector<MesonTools::Tool_
return nullptr;
}
template<typename T>
std::shared_ptr<T> autoDetected(const std::vector<MesonTools::Tool_t> &tools)
static MesonTools::Tool_t autoDetected(const std::vector<MesonTools::Tool_t> &tools, ToolType toolType)
{
static_assert(std::is_base_of<ToolWrapper, T>::value, "Type must derive from ToolWrapper");
for (const auto &tool : tools) {
if (tool->autoDetected() && is<T>(tool)) {
return std::dynamic_pointer_cast<T>(tool);
}
if (tool->autoDetected() && tool->toolType() == toolType)
return tool;
}
return nullptr;
}
template<typename T>
void fixAutoDetected(std::vector<MesonTools::Tool_t> &tools)
static void fixAutoDetected(std::vector<MesonTools::Tool_t> &tools, ToolType toolType)
{
auto autoDetectedTool = autoDetected<T>(tools);
MesonTools::Tool_t autoDetectedTool = autoDetected(tools, toolType);
if (!autoDetectedTool) {
auto path = T::find();
if (path)
tools.emplace_back(std::make_shared<T>(
QString("System %1 at %2").arg(T::toolName()).arg(path->toString()), *path, true));
QStringList exeNames;
QString toolName;
if (toolType == ToolType::Meson) {
if (std::optional<FilePath> path = findMesonTool()) {
tools.emplace_back(
std::make_shared<ToolWrapper>(toolType,
QString("System %1 at %2").arg("Meson").arg(path->toString()), *path, true));
}
} else if (toolType == ToolType::Ninja) {
if (std::optional<FilePath> path = findNinjaTool()) {
tools.emplace_back(
std::make_shared<ToolWrapper>(toolType,
QString("System %1 at %2").arg("Ninja").arg(path->toString()), *path, true));
}
}
}
}
@@ -64,8 +75,8 @@ void MesonTools::setTools(std::vector<MesonTools::Tool_t> &&tools)
{
auto self = instance();
std::swap(self->m_tools, tools);
fixAutoDetected<MesonWrapper>(self->m_tools);
fixAutoDetected<NinjaWrapper>(self->m_tools);
fixAutoDetected(self->m_tools, ToolType::Meson);
fixAutoDetected(self->m_tools, ToolType::Ninja);
}
std::shared_ptr<NinjaWrapper> MesonTools::ninjaWrapper(const Utils::Id &id)
@@ -79,12 +90,14 @@ std::shared_ptr<MesonWrapper> MesonTools::mesonWrapper(const Utils::Id &id)
std::shared_ptr<NinjaWrapper> MesonTools::ninjaWrapper()
{
return autoDetected<NinjaWrapper>(MesonTools::instance()->m_tools);
return std::dynamic_pointer_cast<NinjaWrapper>(
autoDetected(MesonTools::instance()->m_tools, ToolType::Ninja));
}
std::shared_ptr<MesonWrapper> MesonTools::mesonWrapper()
{
return autoDetected<MesonWrapper>(MesonTools::instance()->m_tools);
return std::dynamic_pointer_cast<MesonWrapper>(
autoDetected(MesonTools::instance()->m_tools, ToolType::Meson));
}
} // namespace Internal

4
src/plugins/mesonprojectmanager/mesontools.h
View File

@@ -30,9 +30,9 @@ public:
{
// TODO improve this
if (exe.fileName().contains("ninja"))
addTool(std::make_shared<NinjaWrapper>(name, exe, itemId));
addTool(std::make_shared<ToolWrapper>(ToolType::Ninja, name, exe, itemId));
else
addTool(std::make_shared<MesonWrapper>(name, exe, itemId));
addTool(std::make_shared<ToolWrapper>(ToolType::Meson, name, exe, itemId));
}
static inline void addTool(Tool_t meson)

12
src/plugins/mesonprojectmanager/tests/testmesoninfoparser.cpp
View File

@@ -16,8 +16,6 @@
#include <QTemporaryFile>
#include <QtTest/QtTest>
#include <iostream>
using namespace MesonProjectManager::Internal;
using namespace Utils;
@@ -36,9 +34,9 @@ static const QList<projectData> projectList{
{ \
QTemporaryFile _intro_file; \
_intro_file.open(); \
const auto tool = MesonWrapper::find(); \
const auto tool = findMesonTool(); \
QVERIFY(tool.has_value()); \
const auto _meson = MesonWrapper("name", *tool); \
const MesonWrapper _meson(ToolType::Meson, "name", *tool); \
run_meson(_meson.introspect(Utils::FilePath::fromString(_source_dir)), &_intro_file); \
__VA_ARGS__ \
}
@@ -55,7 +53,7 @@ private slots:
Utils::LauncherInterface::setPathToLauncher(qApp->applicationDirPath() + '/'
+ QLatin1String(TEST_RELATIVE_LIBEXEC_PATH));
const auto path = MesonWrapper::find();
const auto path = findMesonTool();
if (!path)
QSKIP("Meson not found");
}
@@ -78,9 +76,9 @@ private slots:
{
QTemporaryDir build_dir{"test-meson"};
FilePath buildDir = FilePath::fromString(build_dir.path());
const auto tool = MesonWrapper::find();
const auto tool = findMesonTool();
QVERIFY(tool.has_value());
MesonWrapper meson("name", *tool);
MesonWrapper meson(ToolType::Meson, "name", *tool);
run_meson(meson.setup(FilePath::fromString(src_dir), buildDir));
QVERIFY(isSetup(buildDir));

10
src/plugins/mesonprojectmanager/tests/testmesonwrapper.cpp
View File

@@ -34,21 +34,21 @@ private slots:
Utils::LauncherInterface::setPathToLauncher(qApp->applicationDirPath() + '/'
+ QLatin1String(TEST_RELATIVE_LIBEXEC_PATH));
const auto path = MesonWrapper::find();
const auto path = findMesonTool();
if (!path)
QSKIP("Meson not found");
}
void shouldFindMesonFromPATH()
{
const auto path = MesonWrapper::find();
const auto path = findMesonTool();
QVERIFY(path);
QVERIFY(path->exists());
}
void shouldReportMesonVersion()
{
const auto meson = MesonWrapper("name", *MesonWrapper::find());
ToolWrapper meson(ToolType::Meson, "name", *findMesonTool());
QVERIFY(meson.isValid());
QVERIFY(meson.version().major == 0);
QVERIFY(meson.version().minor >= 50);
@@ -69,7 +69,7 @@ private slots:
{
QFETCH(QString, src_dir);
QTemporaryDir build_dir{"test-meson"};
const auto meson = MesonWrapper("name", *MesonWrapper::find());
const MesonWrapper meson(ToolType::Meson, "name", *findMesonTool());
QVERIFY(run_meson(meson.setup(Utils::FilePath::fromString(src_dir),
Utils::FilePath::fromString(build_dir.path()))));
QVERIFY(
@@ -90,7 +90,7 @@ private slots:
{
QFETCH(QString, src_dir);
QTemporaryDir build_dir{"test-meson"};
const auto meson = MesonWrapper("name", *MesonWrapper::find());
const MesonWrapper meson(ToolType::Meson, "name", *findMesonTool());
QVERIFY(run_meson(meson.setup(Utils::FilePath::fromString(src_dir),
Utils::FilePath::fromString(build_dir.path()))));
QVERIFY(run_meson(meson.configure(Utils::FilePath::fromString(src_dir),

2
src/plugins/mesonprojectmanager/toolkitaspectwidget.cpp
View File

@@ -18,8 +18,6 @@ using namespace Utils;
namespace MesonProjectManager::Internal {
enum class ToolType { Meson, Ninja };
// Meson/Ninja KitAspect base
class MesonToolKitAspectImpl final : public KitAspect

16
src/plugins/mesonprojectmanager/toolssettingsaccessor.cpp
View File

@@ -14,7 +14,6 @@
#include <QGuiApplication>
#include <iterator>
#include <vector>
using namespace Core;
@@ -55,15 +54,8 @@ void ToolsSettingsAccessor::saveMesonTools(const std::vector<MesonTools::Tool_t>
Store data;
int entry_count = 0;
for (const MesonTools::Tool_t &tool : tools) {
auto asMeson = std::dynamic_pointer_cast<MesonWrapper>(tool);
if (asMeson)
data.insert(entryName(entry_count), variantFromStore(toVariantMap<MesonWrapper>(*asMeson)));
else {
auto asNinja = std::dynamic_pointer_cast<NinjaWrapper>(tool);
if (asNinja)
data.insert(entryName(entry_count), variantFromStore(toVariantMap<NinjaWrapper>(*asNinja)));
}
entry_count++;
data.insert(entryName(entry_count), variantFromStore(tool->toVariantMap()));
++entry_count;
}
data.insert(ToolsSettings::ENTRY_COUNT, entry_count);
saveSettings(data, ICore::dialogParent());
@@ -80,9 +72,9 @@ std::vector<MesonTools::Tool_t> ToolsSettingsAccessor::loadMesonTools()
Store store = storeFromVariant(data[name]);
QString type = store.value(ToolsSettings::TOOL_TYPE_KEY).toString();
if (type == ToolsSettings::TOOL_TYPE_NINJA)
result.emplace_back(fromVariantMap<NinjaWrapper *>(storeFromVariant(data[name])));
result.emplace_back(ToolWrapper::fromVariantMap(storeFromVariant(data[name]), ToolType::Ninja));
else if (type == ToolsSettings::TOOL_TYPE_MESON)
result.emplace_back(fromVariantMap<MesonWrapper *>(storeFromVariant(data[name])));
result.emplace_back(ToolWrapper::fromVariantMap(storeFromVariant(data[name]), ToolType::Meson));
else
QTC_CHECK(false);
}

53
src/plugins/mesonprojectmanager/toolwrapper.cpp
View File

@@ -20,8 +20,12 @@ namespace Internal {
// ToolWrapper base
ToolWrapper::ToolWrapper(const QString &name, const Utils::FilePath &path, bool autoDetected)
: m_version(read_version(path))
ToolWrapper::ToolWrapper(ToolType toolType,
const QString &name,
const FilePath &path,
bool autoDetected)
: m_toolType(toolType)
, m_version(read_version(path))
, m_isValid{path.exists() && m_version.isValid}
, m_autoDetected{autoDetected}
, m_id{Utils::Id::generate()}
@@ -29,11 +33,13 @@ ToolWrapper::ToolWrapper(const QString &name, const Utils::FilePath &path, bool
, m_name{name}
{}
ToolWrapper::ToolWrapper(const QString &name,
const Utils::FilePath &path,
const Utils::Id &id,
ToolWrapper::ToolWrapper(ToolType toolType,
const QString &name,
const FilePath &path,
const Id &id,
bool autoDetected)
: m_version(read_version(path))
: m_toolType(toolType)
, m_version(read_version(path))
, m_isValid{path.exists() && m_version.isValid}
, m_autoDetected{autoDetected}
, m_id{id}
@@ -61,6 +67,29 @@ Version ToolWrapper::read_version(const Utils::FilePath &toolPath)
return {};
}
Store ToolWrapper::toVariantMap() const
{
Utils::Store data;
data.insert(Constants::ToolsSettings::NAME_KEY, m_name);
data.insert(Constants::ToolsSettings::EXE_KEY, m_exe.toSettings());
data.insert(Constants::ToolsSettings::AUTO_DETECTED_KEY, m_autoDetected);
data.insert(Constants::ToolsSettings::ID_KEY, m_id.toSetting());
if (m_toolType == ToolType::Meson)
data.insert(Constants::ToolsSettings::TOOL_TYPE_KEY, Constants::ToolsSettings::TOOL_TYPE_MESON);
else
data.insert(Constants::ToolsSettings::TOOL_TYPE_KEY, Constants::ToolsSettings::TOOL_TYPE_NINJA);
return data;
}
ToolWrapper *ToolWrapper::fromVariantMap(const Store &data, ToolType toolType)
{
return new ToolWrapper(toolType,
data[Constants::ToolsSettings::NAME_KEY].toString(),
Utils::FilePath::fromSettings(data[Constants::ToolsSettings::EXE_KEY]),
Utils::Id::fromSetting(data[Constants::ToolsSettings::ID_KEY]),
data[Constants::ToolsSettings::AUTO_DETECTED_KEY].toBool());
}
static std::optional<FilePath> findTool(const QStringList &exeNames)
{
Environment systemEnvironment = Environment::systemEnvironment();
@@ -133,11 +162,6 @@ Command MesonWrapper::introspect(const Utils::FilePath &sourceDirectory) const
sourceDirectory};
}
std::optional<FilePath> MesonWrapper::find()
{
return findTool({"meson.py", "meson"});
}
template<typename File_t>
bool containsFiles(const QString &path, const File_t &file)
{
@@ -178,9 +202,12 @@ bool isSetup(const Utils::FilePath &buildPath)
Constants::MESON_INTRO_BUILDSYSTEM_FILES);
}
// NinjaWrapper
std::optional<FilePath> findMesonTool()
{
return findTool({"meson.py", "meson"});
}
std::optional<FilePath> NinjaWrapper::find()
std::optional<FilePath> findNinjaTool()
{
return findTool({"ninja", "ninja-build"});
}

73
src/plugins/mesonprojectmanager/toolwrapper.h
View File

@@ -15,6 +15,8 @@
namespace MesonProjectManager {
namespace Internal {
enum class ToolType { Meson, Ninja };
class Command
{
public:
@@ -27,8 +29,12 @@ class ToolWrapper
public:
virtual ~ToolWrapper() {}
ToolWrapper() = delete;
ToolWrapper(const QString &name, const Utils::FilePath &path, bool autoDetected = false);
ToolWrapper(const QString &name,
ToolWrapper(ToolType toolType,
const QString &name,
const Utils::FilePath &path,
bool autoDetected = false);
ToolWrapper(ToolType toolType,
const QString &name,
const Utils::FilePath &path,
const Utils::Id &id,
bool autoDetected = false);
@@ -49,12 +55,14 @@ public:
static Version read_version(const Utils::FilePath &toolPath);
template<typename T>
friend Utils::Store toVariantMap(const T &);
template<typename T>
friend T fromVariantMap(const Utils::Store &);
Utils::Store toVariantMap() const;
static ToolWrapper *fromVariantMap(const Utils::Store &, ToolType toolType);
ToolType toolType() const { return m_toolType; }
void setToolType(ToolType newToolType) { m_toolType = newToolType; }
protected:
ToolType m_toolType;
Version m_version;
bool m_isValid;
bool m_autoDetected;
@@ -63,11 +71,6 @@ protected:
QString m_name;
};
template<typename T>
Utils::Store toVariantMap(const T &);
template<typename T>
T fromVariantMap(const Utils::Store &);
bool run_meson(const Command &command, QIODevice *output = nullptr);
bool isSetup(const Utils::FilePath &buildPath);
@@ -88,60 +91,16 @@ public:
const Utils::FilePath &buildDirectory) const;
Command introspect(const Utils::FilePath &sourceDirectory) const;
static std::optional<Utils::FilePath> find();
static QString toolName() { return {"Meson"}; }
};
template<>
inline Utils::Store toVariantMap<MesonWrapper>(const MesonWrapper &meson)
{
Utils::Store data;
data.insert(Constants::ToolsSettings::NAME_KEY, meson.m_name);
data.insert(Constants::ToolsSettings::EXE_KEY, meson.m_exe.toSettings());
data.insert(Constants::ToolsSettings::AUTO_DETECTED_KEY, meson.m_autoDetected);
data.insert(Constants::ToolsSettings::ID_KEY, meson.m_id.toSetting());
data.insert(Constants::ToolsSettings::TOOL_TYPE_KEY, Constants::ToolsSettings::TOOL_TYPE_MESON);
return data;
}
template<>
inline MesonWrapper *fromVariantMap<MesonWrapper *>(const Utils::Store &data)
{
return new MesonWrapper(data[Constants::ToolsSettings::NAME_KEY].toString(),
Utils::FilePath::fromSettings(data[Constants::ToolsSettings::EXE_KEY]),
Utils::Id::fromSetting(data[Constants::ToolsSettings::ID_KEY]),
data[Constants::ToolsSettings::AUTO_DETECTED_KEY].toBool());
}
class NinjaWrapper final : public ToolWrapper
{
public:
using ToolWrapper::ToolWrapper;
static std::optional<Utils::FilePath> find();
static QString toolName() { return {"Ninja"}; }
};
template<>
inline Utils::Store toVariantMap<NinjaWrapper>(const NinjaWrapper &meson)
{
Utils::Store data;
data.insert(Constants::ToolsSettings::NAME_KEY, meson.m_name);
data.insert(Constants::ToolsSettings::EXE_KEY, meson.m_exe.toSettings());
data.insert(Constants::ToolsSettings::AUTO_DETECTED_KEY, meson.m_autoDetected);
data.insert(Constants::ToolsSettings::ID_KEY, meson.m_id.toSetting());
data.insert(Constants::ToolsSettings::TOOL_TYPE_KEY, Constants::ToolsSettings::TOOL_TYPE_NINJA);
return data;
}
template<>
inline NinjaWrapper *fromVariantMap<NinjaWrapper *>(const Utils::Store &data)
{
return new NinjaWrapper(data[Constants::ToolsSettings::NAME_KEY].toString(),
Utils::FilePath::fromSettings(data[Constants::ToolsSettings::EXE_KEY]),
Utils::Id::fromSetting(data[Constants::ToolsSettings::ID_KEY]),
data[Constants::ToolsSettings::AUTO_DETECTED_KEY].toBool());
}
std::optional<Utils::FilePath> findMesonTool();
std::optional<Utils::FilePath> findNinjaTool();
} // namespace Internal
} // namespace MesonProjectManager