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

Nim: Rework NimbleTaskStep

Browse Source 
Use StringAspects for m_taskArgs and m_taskName.

Change-Id: I69496029e3f414012c06e8217debfe2507d75cc6
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
This commit is contained in:
hjk
2020-09-03 10:13:42 +02:00
parent 1e452f1ad3
commit ec75575e64
2 changed files with 87 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

185
src/plugins/nim/project/nimbletaskstep.cpp
View File

@@ -29,10 +29,13 @@
#include "nimblebuildsystem.h"
#include "nimbleproject.h"
#include <projectexplorer/abstractprocessstep.h>
#include <projectexplorer/buildstep.h>
#include <projectexplorer/buildconfiguration.h>
#include <projectexplorer/processparameters.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/projectconfigurationaspects.h>
#include <projectexplorer/target.h>
#include <utils/algorithm.h>
#include <utils/fileutils.h>
@@ -44,80 +47,107 @@
#include <QStandardPaths>
using namespace ProjectExplorer;
using namespace Utils;
namespace Nim {
class NimbleTaskStepWidget : public BuildStepConfigWidget
class NimbleTaskStep final : public AbstractProcessStep
{
Q_DECLARE_TR_FUNCTIONS(Nim::NimbleTaskStep)
public:
explicit NimbleTaskStepWidget(NimbleTaskStep *buildStep);
void selectedTaskChanged(const QString &name)
{
auto taskStep = dynamic_cast<NimbleTaskStep *>(step());
QTC_ASSERT(taskStep, return);
taskStep->setTaskName(name);
}
NimbleTaskStep(BuildStepList *parentList, Id id);
private:
bool init() final;
BuildStepConfigWidget *createConfigWidget() final;
void setTaskName(const QString &name);
void updateTaskList();
void selectTask(const QString &name);
void onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles);
void uncheckedAllDifferentFrom(QStandardItem *item);
bool validate();
StringAspect *m_taskName = nullptr;
StringAspect *m_taskArgs = nullptr;
QStandardItemModel m_tasks;
bool m_selecting = false;
};
NimbleTaskStepWidget::NimbleTaskStepWidget(NimbleTaskStep *bs)
: BuildStepConfigWidget(bs)
NimbleTaskStep::NimbleTaskStep(BuildStepList *parentList, Id id)
: AbstractProcessStep(parentList, id)
{
auto taskArgumentsLineEdit = new QLineEdit(this);
taskArgumentsLineEdit->setText(bs->taskArgs());
setDefaultDisplayName(tr(Constants::C_NIMBLETASKSTEP_DISPLAY));
setDisplayName(tr(Constants::C_NIMBLETASKSTEP_DISPLAY));
auto taskList = new QListView(this);
setCommandLineProvider([this] {
QString args = m_taskName->value() + " " + m_taskArgs->value();
return CommandLine(Nim::nimblePathFromKit(target()->kit()), args, CommandLine::Raw);
});
setWorkingDirectoryProvider([this] { return project()->projectDirectory(); });
m_taskName = addAspect<StringAspect>();
m_taskName->setSettingsKey(Constants::C_NIMBLETASKSTEP_TASKNAME);
m_taskArgs = addAspect<StringAspect>();
m_taskArgs->setSettingsKey(Constants::C_NIMBLETASKSTEP_TASKARGS);
m_taskArgs->setDisplayStyle(StringAspect::LineEditDisplay);
m_taskArgs->setLabelText(tr("Task arguments:"));
}
bool NimbleTaskStep::init()
{
if (!AbstractProcessStep::init())
return false;
setupProcessParameters(processParameters());
return validate();
}
BuildStepConfigWidget *NimbleTaskStep::createConfigWidget()
{
auto widget = new BuildStepConfigWidget(this);
auto taskList = new QListView(widget);
taskList->setFrameShape(QFrame::StyledPanel);
taskList->setSelectionMode(QAbstractItemView::NoSelection);
taskList->setSelectionBehavior(QAbstractItemView::SelectRows);
taskList->setModel(&m_tasks);
auto formLayout = new QFormLayout(this);
formLayout->setSizeConstraint(QLayout::SetDefaultConstraint);
formLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
LayoutBuilder builder(widget);
builder.addRow(m_taskArgs);
builder.startNewRow().addItems(tr("Tasks:"), taskList);
formLayout->addRow(tr("Task arguments:"), taskArgumentsLineEdit);
formLayout->addRow(tr("Tasks:"), taskList);
auto buildSystem = dynamic_cast<NimbleBuildSystem *>(bs->buildSystem());
QTC_ASSERT(buildSystem, return);
connect(&m_tasks, &QAbstractItemModel::dataChanged, this, &NimbleTaskStepWidget::onDataChanged);
auto buildSystem = dynamic_cast<NimbleBuildSystem *>(this->buildSystem());
QTC_ASSERT(buildSystem, return widget);
updateTaskList();
connect(buildSystem, &NimbleBuildSystem::tasksChanged, this, &NimbleTaskStepWidget::updateTaskList);
selectTask(m_taskName->value());
selectTask(bs->taskName());
connect(bs, &NimbleTaskStep::taskNameChanged, this, &NimbleTaskStepWidget::selectTask);
connect(bs, &NimbleTaskStep::taskNameChanged, this, &NimbleTaskStepWidget::recreateSummary);
connect(&m_tasks, &QAbstractItemModel::dataChanged, this, &NimbleTaskStep::onDataChanged);
connect(bs, &NimbleTaskStep::taskArgsChanged, taskArgumentsLineEdit, &QLineEdit::setText);
connect(bs, &NimbleTaskStep::taskArgsChanged, this, &NimbleTaskStepWidget::recreateSummary);
connect(taskArgumentsLineEdit, &QLineEdit::textChanged, bs ,&NimbleTaskStep::setTaskArgs);
connect(buildSystem, &NimbleBuildSystem::tasksChanged, this, &NimbleTaskStep::updateTaskList);
setSummaryUpdater([this, bs] {
connect(m_taskName, &StringAspect::changed, widget, &BuildStepConfigWidget::recreateSummary);
connect(m_taskArgs, &StringAspect::changed, widget, &BuildStepConfigWidget::recreateSummary);
widget->setSummaryUpdater([this] {
return QString("<b>%1:</b> nimble %2 %3")
.arg(displayName(), bs->taskName(), bs->taskArgs());
.arg(displayName(), m_taskName->value(), m_taskArgs->value());
});
return widget;
}
void NimbleTaskStepWidget::updateTaskList()
void NimbleTaskStep::updateTaskList()
{
auto buildSystem = dynamic_cast<NimbleBuildSystem *>(step()->buildSystem());
auto buildSystem = dynamic_cast<NimbleBuildSystem *>(this->buildSystem());
QTC_ASSERT(buildSystem, return);
const std::vector<NimbleTask> &tasks = buildSystem->tasks();
@@ -149,7 +179,7 @@ void NimbleTaskStepWidget::updateTaskList()
m_tasks.sort(0);
}
void NimbleTaskStepWidget::selectTask(const QString &name)
void NimbleTaskStep::selectTask(const QString &name)
{
if (m_selecting)
return;
@@ -161,12 +191,12 @@ void NimbleTaskStepWidget::selectTask(const QString &name)
if (item)
item->setCheckState(Qt::Checked);
selectedTaskChanged(name);
setTaskName(name);
m_selecting = false;
}
void NimbleTaskStepWidget::onDataChanged(const QModelIndex &topLeft,
void NimbleTaskStep::onDataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight,
const QVector<int> &roles)
{
@@ -184,15 +214,15 @@ void NimbleTaskStepWidget::onDataChanged(const QModelIndex &topLeft,
if (item->checkState() == Qt::Checked) {
uncheckedAllDifferentFrom(item);
selectedTaskChanged(item->text());
setTaskName(item->text());
} else if (item->checkState() == Qt::Unchecked) {
selectedTaskChanged(QString());
setTaskName(QString());
}
m_selecting = false;
}
void NimbleTaskStepWidget::uncheckedAllDifferentFrom(QStandardItem *toSkip)
void NimbleTaskStep::uncheckedAllDifferentFrom(QStandardItem *toSkip)
{
for (int i = 0; i < m_tasks.rowCount(); ++i) {
auto item = m_tasks.item(i);
@@ -202,77 +232,26 @@ void NimbleTaskStepWidget::uncheckedAllDifferentFrom(QStandardItem *toSkip)
}
}
NimbleTaskStep::NimbleTaskStep(BuildStepList *parentList, Utils::Id id)
: AbstractProcessStep(parentList, id)
{
setDefaultDisplayName(tr(Constants::C_NIMBLETASKSTEP_DISPLAY));
setDisplayName(tr(Constants::C_NIMBLETASKSTEP_DISPLAY));
}
bool NimbleTaskStep::init()
{
processParameters()->setEnvironment(buildEnvironment());
processParameters()->setWorkingDirectory(project()->projectDirectory());
return validate() && AbstractProcessStep::init();
}
BuildStepConfigWidget *NimbleTaskStep::createConfigWidget()
{
return new NimbleTaskStepWidget(this);
}
bool NimbleTaskStep::fromMap(const QVariantMap &map)
{
setTaskName(map.value(Constants::C_NIMBLETASKSTEP_TASKNAME, QString()).toString());
setTaskArgs(map.value(Constants::C_NIMBLETASKSTEP_TASKARGS, QString()).toString());
return validate() ? AbstractProcessStep::fromMap(map) : false;
}
QVariantMap NimbleTaskStep::toMap() const
{
QVariantMap result = AbstractProcessStep::toMap();
result[Constants::C_NIMBLETASKSTEP_TASKNAME] = taskName();
result[Constants::C_NIMBLETASKSTEP_TASKARGS] = taskArgs();
return result;
}
void NimbleTaskStep::setTaskName(const QString &name)
{
if (m_taskName == name)
if (m_taskName->value() == name)
return;
m_taskName = name;
emit taskNameChanged(name);
updateCommandLine();
}
void NimbleTaskStep::setTaskArgs(const QString &args)
{
if (m_taskArgs == args)
return;
m_taskArgs = args;
emit taskArgsChanged(args);
updateCommandLine();
}
void NimbleTaskStep::updateCommandLine()
{
QString args = m_taskName + " " + m_taskArgs;
Utils::CommandLine commandLine(Utils::FilePath::fromString(QStandardPaths::findExecutable("nimble")),
args, Utils::CommandLine::Raw);
processParameters()->setCommandLine(commandLine);
m_taskName->setValue(name);
selectTask(name);
}
bool NimbleTaskStep::validate()
{
if (m_taskName.isEmpty())
if (m_taskName->value().isEmpty())
return true;
auto nimbleBuildSystem = dynamic_cast<NimbleBuildSystem*>(buildSystem());
QTC_ASSERT(nimbleBuildSystem, return false);
if (!Utils::contains(nimbleBuildSystem->tasks(), [this](const NimbleTask &task){ return task.name == m_taskName; })) {
emit addTask(BuildSystemTask(Task::Error, tr("Nimble task %1 not found.").arg(m_taskName)));
auto matchName = [this](const NimbleTask &task) { return task.name == m_taskName->value(); };
if (!Utils::contains(nimbleBuildSystem->tasks(), matchName)) {
emit addTask(BuildSystemTask(Task::Error, tr("Nimble task %1 not found.")
.arg(m_taskName->value())));
emitFaultyConfigurationMessage();
return false;
}

43
src/plugins/nim/project/nimbletaskstep.h
View File

@@ -25,51 +25,14 @@
#pragma once
#include <projectexplorer/abstractprocessstep.h>
#include <projectexplorer/buildstep.h>
namespace Nim {
class NimbleTaskStep : public ProjectExplorer::AbstractProcessStep
{
Q_OBJECT
public:
NimbleTaskStep(ProjectExplorer::BuildStepList *parentList, Utils::Id id);
bool init() override;
ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
bool fromMap(const QVariantMap &map) override;
QVariantMap toMap() const override;
QString taskName() const { return m_taskName; }
void setTaskName(const QString &name);
QString taskArgs() const { return m_taskArgs; }
void setTaskArgs(const QString &args);
signals:
void taskNameChanged(const QString &name);
void taskArgsChanged(const QString &args);
private:
void updateCommandLine();
bool validate();
QString m_taskName;
QString m_taskArgs;
};
class NimbleTaskStepFactory : public ProjectExplorer::BuildStepFactory
class NimbleTaskStepFactory final : public ProjectExplorer::BuildStepFactory
{
public:
NimbleTaskStepFactory();
};
}
} // Nim