Nim: Rework NimbleTaskStep

Use StringAspects for m_taskArgs and m_taskName.

Change-Id: I69496029e3f414012c06e8217debfe2507d75cc6
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

src/plugins/nim/project/nimbletaskstep.cpp

@@ -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);
+    NimbleTaskStep(BuildStepList *parentList, Id id);
-
-    void selectedTaskChanged(const QString &name)
-    {
-        auto taskStep = dynamic_cast<NimbleTaskStep *>(step());
-        QTC_ASSERT(taskStep, return);
-        taskStep->setTaskName(name);
-    }
 
 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)
+NimbleTaskStep::NimbleTaskStep(BuildStepList *parentList, Id id)
-    : BuildStepConfigWidget(bs)
+    : AbstractProcessStep(parentList, id)
 {
-    auto taskArgumentsLineEdit = new QLineEdit(this);
+    setDefaultDisplayName(tr(Constants::C_NIMBLETASKSTEP_DISPLAY));
-    taskArgumentsLineEdit->setText(bs->taskArgs());
+    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);
+    LayoutBuilder builder(widget);
-    formLayout->setSizeConstraint(QLayout::SetDefaultConstraint);
+    builder.addRow(m_taskArgs);
-    formLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
+    builder.startNewRow().addItems(tr("Tasks:"), taskList);
 
-    formLayout->addRow(tr("Task arguments:"), taskArgumentsLineEdit);
+    auto buildSystem = dynamic_cast<NimbleBuildSystem *>(this->buildSystem());
-    formLayout->addRow(tr("Tasks:"), taskList);
+    QTC_ASSERT(buildSystem, return widget);
-
-    auto buildSystem = dynamic_cast<NimbleBuildSystem *>(bs->buildSystem());
-    QTC_ASSERT(buildSystem, return);
-
-    connect(&m_tasks, &QAbstractItemModel::dataChanged, this, &NimbleTaskStepWidget::onDataChanged);
 
     updateTaskList();
-    connect(buildSystem, &NimbleBuildSystem::tasksChanged, this, &NimbleTaskStepWidget::updateTaskList);
+    selectTask(m_taskName->value());
 
-    selectTask(bs->taskName());
+    connect(&m_tasks, &QAbstractItemModel::dataChanged, this, &NimbleTaskStep::onDataChanged);
-    connect(bs, &NimbleTaskStep::taskNameChanged, this, &NimbleTaskStepWidget::selectTask);
-    connect(bs, &NimbleTaskStep::taskNameChanged, this, &NimbleTaskStepWidget::recreateSummary);
 
-    connect(bs, &NimbleTaskStep::taskArgsChanged, taskArgumentsLineEdit, &QLineEdit::setText);
+    connect(buildSystem, &NimbleBuildSystem::tasksChanged, this, &NimbleTaskStep::updateTaskList);
-    connect(bs, &NimbleTaskStep::taskArgsChanged, this, &NimbleTaskStepWidget::recreateSummary);
-    connect(taskArgumentsLineEdit, &QLineEdit::textChanged, bs ,&NimbleTaskStep::setTaskArgs);
 
-    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;
+    m_taskName->setValue(name);
-    emit taskNameChanged(name);
+    selectTask(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);
 }
 
 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; })) {
+    auto matchName = [this](const NimbleTask &task) { return task.name == m_taskName->value(); };
-        emit addTask(BuildSystemTask(Task::Error, tr("Nimble task %1 not found.").arg(m_taskName)));
+    if (!Utils::contains(nimbleBuildSystem->tasks(), matchName)) {
+        emit addTask(BuildSystemTask(Task::Error, tr("Nimble task %1 not found.")
+                                     .arg(m_taskName->value())));
         emitFaultyConfigurationMessage();
         return false;
     }

src/plugins/nim/project/nimbletaskstep.h

@@ -25,51 +25,14 @@
 
 #pragma once
 
-#include <projectexplorer/abstractprocessstep.h>
+#include <projectexplorer/buildstep.h>
 
 namespace Nim {
 
-class NimbleTaskStep : public ProjectExplorer::AbstractProcessStep
+class NimbleTaskStepFactory final : public ProjectExplorer::BuildStepFactory
-{
-    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
 {
 public:
     NimbleTaskStepFactory();
 };
 
-}
+} // Nim