diff --git a/kdevplatform/shell/workingsets/workingset.cpp b/kdevplatform/shell/workingsets/workingset.cpp
index 101cc7ba16..b4a8082466 100644
--- a/kdevplatform/shell/workingsets/workingset.cpp
+++ b/kdevplatform/shell/workingsets/workingset.cpp
@@ -1,582 +1,582 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "workingset.h"
 #include "debug.h"
 
 #include <sublime/area.h>
 #include <sublime/mainwindow.h>
 
 #include <QPainter>
 
 #include <KProtocolInfo>
 #include <KTextEditor/Document>
 
 #include <textdocument.h>
 #include <core.h>
 #include <interfaces/isession.h>
 #include <uicontroller.h>
 #include <util/pushvalue.h>
 #include <documentcontroller.h>
 #include <workingsetcontroller.h>
 
 #define SYNC_OFTEN
 
 using namespace KDevelop;
 
 bool WorkingSet::m_loading = false;
 
 namespace {
 
 QIcon generateIcon(const WorkingSetIconParameters& params)
 {
     QImage pixmap(16, 16, QImage::Format_ARGB32);
     // fill the background with a transparent color
     pixmap.fill(QColor::fromRgba(qRgba(0, 0, 0, 0)));
     const uint coloredCount = params.coloredCount;
     // coordinates of the rectangles to draw, for 16x16 icons specifically
     QList<QRect> rects{
         {1, 1, 5, 5},
         {1, 9, 5, 5},
         {9, 1, 5, 5},
         {9, 9, 5, 5},
     };
     if ( params.swapDiagonal ) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 13, 0))
         rects.swapItemsAt(1, 2);
 #else
         rects.swap(1, 2);
 #endif
     }
 
     QPainter painter(&pixmap);
     // color for non-colored squares, paint them brighter if the working set is the active one
     const int inact = 40;
     QColor darkColor = QColor::fromRgb(inact, inact, inact);
     // color for colored squares
     // this code is not fragile, you can just tune the magic formulas at random and see what looks good.
     // just make sure to keep it within the 0-360 / 0-255 / 0-255 space of the HSV model
     QColor brightColor = QColor::fromHsv(params.hue, qMin<uint>(255, 215 + (params.setId*5) % 150),
                                          205 + (params.setId*11) % 50);
     // Y'UV "Y" value, the approximate "lightness" of the color
     // If it is above 0.6, then making the color darker a bit is okay,
     // if it is below 0.35, then the color should be a bit brighter.
     float brightY = 0.299 * brightColor.redF() + 0.587 * brightColor.greenF() + 0.114 * brightColor.blueF();
     if ( brightY > 0.6 ) {
         if ( params.setId % 7 < 2 ) {
             // 2/7 chance to make the color significantly darker
             brightColor = brightColor.darker(120 + (params.setId*7) % 35);
         }
         else if ( params.setId % 5 == 0 ) {
             // 1/5 chance to make it a bit darker
             brightColor = brightColor.darker(110 + (params.setId*3) % 10);
         }
     }
     if ( brightY < 0.35 ) {
         // always make the color brighter to avoid very dark colors (like rgb(0, 0, 255))
         brightColor = brightColor.lighter(120 + (params.setId*13) % 55);
     }
     int at = 0;
     for (const QRect& rect : qAsConst(rects)) {
         QColor currentColor;
         // pick the colored squares; you can get different patterns by re-ordering the "rects" list
         if ( (at + params.setId*7) % 4 < coloredCount ) {
             currentColor = brightColor;
         }
         else {
             currentColor = darkColor;
         }
         // draw the filling of the square
         painter.setPen(QColor(currentColor));
         painter.setBrush(QBrush(currentColor));
         painter.drawRect(rect);
         // draw a slight set-in shadow for the square -- it's barely recognizeable,
         // but it looks way better than without
         painter.setBrush(Qt::NoBrush);
         painter.setPen(QColor(0, 0, 0, 50));
         painter.drawRect(rect);
         painter.setPen(QColor(0, 0, 0, 25));
         painter.drawRect(rect.x() + 1, rect.y() + 1, rect.width() - 2, rect.height() - 2);
         at += 1;
     }
     return QIcon(QPixmap::fromImage(pixmap));
 }
 
 }
 
 WorkingSet::WorkingSet(const QString& id)
     : QObject()
     , m_id(id)
     , m_icon(generateIcon(WorkingSetIconParameters(id)))
 {
 }
 
 void WorkingSet::saveFromArea( Sublime::Area* a, Sublime::AreaIndex * area, KConfigGroup setGroup, KConfigGroup areaGroup )
 {
     if (area->isSplit()) {
         setGroup.writeEntry("Orientation", area->orientation() == Qt::Horizontal ? "Horizontal" : "Vertical");
 
         if (area->first()) {
             saveFromArea(a, area->first(), KConfigGroup(&setGroup, "0"), KConfigGroup(&areaGroup, "0"));
         }
 
         if (area->second()) {
             saveFromArea(a, area->second(), KConfigGroup(&setGroup, "1"), KConfigGroup(&areaGroup, "1"));
         }
     } else {
         setGroup.writeEntry("View Count", area->viewCount());
         areaGroup.writeEntry("View Count", area->viewCount());
         int index = 0;
         const auto views = area->views();
         for (Sublime::View* view : views) {
             //The working set config gets an updated list of files
             QString docSpec = view->document()->documentSpecifier();
 
             //only save the documents from protocols KIO understands
             //otherwise we try to load kdev:// too early
             if (!KProtocolInfo::isKnownProtocol(QUrl(docSpec))) {
                 continue;
             }
 
             setGroup.writeEntry(QStringLiteral("View %1").arg(index), docSpec);
             //The area specific config stores the working set documents in order along with their state
             areaGroup.writeEntry(QStringLiteral("View %1").arg(index), docSpec);
             KConfigGroup viewGroup(&areaGroup, QStringLiteral("View %1 Config").arg(index));
             view->writeSessionConfig(viewGroup);
             ++index;
         }
     }
 }
 
 bool WorkingSet::isEmpty() const
 {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     return !group.hasKey("Orientation") && group.readEntry("View Count", 0) == 0;
 }
 
 struct DisableMainWindowUpdatesFromArea
 {
     explicit DisableMainWindowUpdatesFromArea(Sublime::Area* area) : m_area(area) {
         if(area) {
             const auto windows = Core::self()->uiControllerInternal()->mainWindows();
             for (Sublime::MainWindow* window : windows) {
                 if(window->area() == area) {
                     if(window->updatesEnabled()) {
                         wasUpdatesEnabled.insert(window);
                         window->setUpdatesEnabled(false);
                     }
                 }
             }
         }
     }
 
     ~DisableMainWindowUpdatesFromArea() {
         if(m_area) {
             for (Sublime::MainWindow* window : qAsConst(wasUpdatesEnabled)) {
                 window->setUpdatesEnabled(wasUpdatesEnabled.contains(window));
             }
         }
     }
 
     Sublime::Area* m_area;
     QSet<Sublime::MainWindow*> wasUpdatesEnabled;
 };
 
-void loadFileList(QStringList& ret, KConfigGroup group)
+void loadFileList(QStringList& ret, const KConfigGroup& group)
 {
     if (group.hasKey("Orientation")) {
         QStringList subgroups = group.groupList();
 
         if (subgroups.contains(QStringLiteral("0"))) {
 
             {
                 KConfigGroup subgroup(&group, "0");
                 loadFileList(ret, subgroup);
             }
 
             if (subgroups.contains(QStringLiteral("1"))) {
                 KConfigGroup subgroup(&group, "1");
                 loadFileList(ret, subgroup);
             }
         }
 
     } else {
         int viewCount = group.readEntry("View Count", 0);
         ret.reserve(ret.size() + viewCount);
         for (int i = 0; i < viewCount; ++i) {
             QString specifier = group.readEntry(QStringLiteral("View %1").arg(i), QString());
 
             ret << specifier;
         }
     }
 }
 
 QStringList WorkingSet::fileList() const
 {
     QStringList ret;
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
 
     loadFileList(ret, group);
     return ret;
 }
 
 void WorkingSet::loadToArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex) {
     PushValue<bool> enableLoading(m_loading, true);
 
     /// We cannot disable the updates here, because (probably) due to a bug in Qt,
     /// which causes the updates to stay disabled forever after some complex operations
     /// on the sub-views. This could be reproduced by creating two working-sets with complex
     /// split-view configurations and switching between them. Re-enabling the updates doesn't help.
 //     DisableMainWindowUpdatesFromArea updatesDisabler(area);
 
     qCDebug(SHELL) << "loading working-set" << m_id << "into area" << area;
 
     QMultiMap<QString, Sublime::View*> recycle;
 
     const auto viewsBefore = area->views();
     for (Sublime::View* view : viewsBefore) {
         recycle.insert( view->document()->documentSpecifier(), area->removeView(view) );
     }
 
     qCDebug(SHELL) << "recycling" << recycle.size() << "old views";
 
     Q_ASSERT( area->views().empty() );
 
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup setGroup = setConfig.group(m_id);
     KConfigGroup areaGroup = setConfig.group(m_id + QLatin1Char('|') + area->title());
 
     loadToArea(area, areaIndex, setGroup, areaGroup, recycle);
 
     // Delete views which were not recycled
     qCDebug(SHELL) << "deleting " << recycle.size() << " old views";
     qDeleteAll( recycle );
 
     area->setActiveView(nullptr);
 
     //activate view in the working set
     /// @todo correctly select one out of multiple equal views
     QString activeView = areaGroup.readEntry("Active View", QString());
     const auto viewsAfter = area->views();
     for (Sublime::View* v : viewsAfter) {
         if (v->document()->documentSpecifier() == activeView) {
             area->setActiveView(v);
             break;
         }
     }
 
     if( !area->activeView() && !area->views().isEmpty() )
         area->setActiveView( area->views().at(0) );
 
     if( area->activeView() ) {
         const auto windows = Core::self()->uiControllerInternal()->mainWindows();
         for (Sublime::MainWindow* window : windows) {
                 if(window->area() == area) {
                     window->activateView( area->activeView() );
                 }
         }
     }
 }
 
 void WorkingSet::loadToArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex, const KConfigGroup& setGroup, const KConfigGroup& areaGroup, QMultiMap<QString, Sublime::View*>& recycle)
 {
     Q_ASSERT( !areaIndex->isSplit() );
     if (setGroup.hasKey("Orientation")) {
         QStringList subgroups = setGroup.groupList();
         /// @todo also save and restore the ratio
 
         if (subgroups.contains(QStringLiteral("0")) && subgroups.contains(QStringLiteral("1"))) {
 //             qCDebug(SHELL) << "has zero, split:" << split;
 
             Qt::Orientation orientation = setGroup.readEntry("Orientation", "Horizontal") == QLatin1String("Vertical") ? Qt::Vertical : Qt::Horizontal;
             if(!areaIndex->isSplit()){
                 areaIndex->split(orientation);
             }else{
                 areaIndex->setOrientation(orientation);
             }
 
             loadToArea(area, areaIndex->first(), KConfigGroup(&setGroup, "0"), KConfigGroup(&areaGroup, "0"), recycle);
 
             loadToArea(area, areaIndex->second(), KConfigGroup(&setGroup, "1"), KConfigGroup(&areaGroup, "1"), recycle);
 
             if( areaIndex->first()->viewCount() == 0 )
                 areaIndex->unsplit(areaIndex->first());
             else if( areaIndex->second()->viewCount() == 0 )
                 areaIndex->unsplit(areaIndex->second());
         }
     } else {
 
         //Load all documents from the workingset into this areaIndex
         int viewCount = setGroup.readEntry("View Count", 0);
         QMap<int, Sublime::View*> createdViews;
         for (int i = 0; i < viewCount; ++i) {
             QString specifier = setGroup.readEntry(QStringLiteral("View %1").arg(i), QString());
             if (specifier.isEmpty()) {
                 continue;
             }
             Sublime::View* previousView = area->views().empty() ? nullptr : area->views().at(area->views().size() - 1);
 
             QMultiMap<QString, Sublime::View*>::iterator it = recycle.find( specifier );
             if( it != recycle.end() )
             {
                 area->addView( *it, areaIndex, previousView );
                 recycle.erase( it );
                 continue;
             }
             IDocument* doc = Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(specifier),
                              KTextEditor::Cursor::invalid(), IDocumentController::DoNotActivate | IDocumentController::DoNotCreateView);
             auto *document = dynamic_cast<Sublime::Document*>(doc);
             if (document) {
                 Sublime::View* view = document->createView();
                 area->addView(view, areaIndex, previousView);
                 createdViews[i] = view;
             } else {
                 qCWarning(SHELL) << "Unable to create view" << specifier;
             }
         }
 
         //Load state
         for (int i = 0; i < viewCount; ++i)
         {
             KConfigGroup viewGroup(&areaGroup, QStringLiteral("View %1 Config").arg(i));
             if (viewGroup.exists() && createdViews.contains(i))
                 createdViews[i]->readSessionConfig(viewGroup);
         }
     }
 }
 
 void deleteGroupRecursive(KConfigGroup group) {
 //     qCDebug(SHELL) << "deleting" << group.name();
     const auto entryMap = group.entryMap();
     for (auto it = entryMap.begin(), end = entryMap.end(); it != end; ++it) {
         group.deleteEntry(it.key());
     }
     Q_ASSERT(group.entryMap().isEmpty());
 
     const auto groupList = group.groupList();
     for (const QString& subGroup : groupList) {
         deleteGroupRecursive(group.group(subGroup));
         group.deleteGroup(subGroup);
     }
     //Why doesn't this work?
 //     Q_ASSERT(group.groupList().isEmpty());
     group.deleteGroup();
 }
 
 void WorkingSet::deleteSet(bool force, bool silent)
 {
     if(m_areas.isEmpty() || force) {
         emit aboutToRemove(this);
 
         KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
         KConfigGroup group = setConfig.group(m_id);
         deleteGroupRecursive(group);
 #ifdef SYNC_OFTEN
         setConfig.sync();
 #endif
 
         if(!silent)
             emit setChangedSignificantly();
     }
 }
 
 void WorkingSet::saveFromArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex)
 {
     qCDebug(SHELL) << "saving" << m_id << "from area";
 
     bool wasPersistent = isPersistent();
 
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
 
     KConfigGroup setGroup = setConfig.group(m_id);
     deleteGroupRecursive(setGroup);
 
     KConfigGroup areaGroup = setConfig.group(m_id + QLatin1Char('|') + area->title());
     QString lastActiveView = areaGroup.readEntry("Active View", "");
     deleteGroupRecursive(areaGroup);
     if (area->activeView() && area->activeView()->document())
         areaGroup.writeEntry("Active View", area->activeView()->document()->documentSpecifier());
     else
         areaGroup.writeEntry("Active View", lastActiveView);
 
     saveFromArea(area, areaIndex, setGroup, areaGroup);
 
     if(isEmpty())
     {
         deleteGroupRecursive(setGroup);
         deleteGroupRecursive(areaGroup);
     }
 
     setPersistent(wasPersistent);
 
 #ifdef SYNC_OFTEN
     setConfig.sync();
 #endif
 
     emit setChangedSignificantly();
 }
 
 void WorkingSet::areaViewAdded(Sublime::AreaIndex*, Sublime::View*) {
     auto* area = qobject_cast<Sublime::Area*>(sender());
     Q_ASSERT(area);
     Q_ASSERT(area->workingSet() == m_id);
 
     qCDebug(SHELL) << "added view in" << area << ", id" << m_id;
     if (m_loading) {
         qCDebug(SHELL) << "doing nothing because loading";
         return;
     }
 
     changed(area);
 }
 
 void WorkingSet::areaViewRemoved(Sublime::AreaIndex*, Sublime::View* view) {
     auto* area = qobject_cast<Sublime::Area*>(sender());
     Q_ASSERT(area);
     Q_ASSERT(area->workingSet() == m_id);
 
     qCDebug(SHELL) << "removed view in" << area << ", id" << m_id;
     if (m_loading) {
         qCDebug(SHELL) << "doing nothing because loading";
         return;
     }
 
     const auto areasBefore = m_areas; // TODO: check if areas could be changed, otherwise use m_areas directly
     for (Sublime::Area* otherArea : areasBefore) {
         if(otherArea == area)
             continue;
         const auto otherAreaViews = otherArea->views();
         bool hadDocument = std::any_of(otherAreaViews.begin(), otherAreaViews.end(), [&](Sublime::View* otherView) {
             return (view->document() == otherView->document());
         });
 
         if(!hadDocument)
         {
             // We do this to prevent UI flicker. The view has already been removed from
             // one of the connected areas, so the working-set has already recorded the change.
             return;
         }
 
     }
 
     changed(area);
 }
 
 void WorkingSet::setPersistent(bool persistent) {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     group.writeEntry("persistent", persistent);
 #ifdef SYNC_OFTEN
     group.sync();
 #endif
     qCDebug(SHELL) << "setting" << m_id << "persistent:" << persistent;
 }
 
 bool WorkingSet::isPersistent() const {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     return group.readEntry("persistent", false);
 }
 
 QIcon WorkingSet::icon() const
 {
     return m_icon;
 }
 
 bool WorkingSet::isConnected( Sublime::Area* area )
 {
   return m_areas.contains( area );
 }
 
 QString WorkingSet::id() const
 {
   return m_id;
 }
 
 bool WorkingSet::hasConnectedAreas() const
 {
   return !m_areas.isEmpty();
 }
 
 bool WorkingSet::hasConnectedAreas(const QList<Sublime::Area*>& areas) const
 {
     for (Sublime::Area* area : areas) {
         if (m_areas.contains(area))
             return true;
     }
 
   return false;
 }
 
 void WorkingSet::connectArea( Sublime::Area* area )
 {
   if ( m_areas.contains( area ) ) {
     qCDebug(SHELL) << "tried to double-connect area";
     return;
   }
 
   qCDebug(SHELL) << "connecting" << m_id << "to area" << area;
 
 //         Q_ASSERT(area->workingSet() == m_id);
 
   m_areas.push_back( area );
   connect( area, &Sublime::Area::viewAdded, this, &WorkingSet::areaViewAdded );
   connect( area, &Sublime::Area::viewRemoved, this, &WorkingSet::areaViewRemoved );
 }
 
 void WorkingSet::disconnectArea( Sublime::Area* area )
 {
   if ( !m_areas.contains( area ) ) {
     qCDebug(SHELL) << "tried to disconnect not connected area";
     return;
   }
 
   qCDebug(SHELL) << "disconnecting" << m_id << "from area" << area;
 
 //         Q_ASSERT(area->workingSet() == m_id);
 
   disconnect( area, &Sublime::Area::viewAdded, this, &WorkingSet::areaViewAdded );
   disconnect( area, &Sublime::Area::viewRemoved, this, &WorkingSet::areaViewRemoved );
   m_areas.removeAll( area );
 }
 
 void WorkingSet::changed( Sublime::Area* area )
 {
   if ( m_loading ) {
     return;
   }
 
   {
     //Do not capture changes done while loading
     PushValue<bool> enableLoading( m_loading, true );
 
     qCDebug(SHELL) << "recording change done to" << m_id;
     saveFromArea( area, area->rootIndex() );
 
     for (auto it = m_areas.begin(); it != m_areas.end(); ++it ) {
       if (( *it ) != area ) {
         loadToArea(( *it ), ( *it )->rootIndex() );
       }
     }
   }
 
   emit setChangedSignificantly();
 }
 
diff --git a/plugins/customscript/customscript_plugin.cpp b/plugins/customscript/customscript_plugin.cpp
index b0e8424c66..bf10db0077 100644
--- a/plugins/customscript/customscript_plugin.cpp
+++ b/plugins/customscript/customscript_plugin.cpp
@@ -1,571 +1,571 @@
 /* This file is part of KDevelop
    Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2011 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "customscript_plugin.h"
 
 #include <KPluginFactory>
 #include <QTextStream>
 #include <QTemporaryFile>
 #include <QMimeDatabase>
 #include <KProcess>
 #include <interfaces/icore.h>
 #include <interfaces/isourceformattercontroller.h>
 #include <interfaces/isourceformatter.h>
 #include <memory>
 #include <QDir>
 #include <QTimer>
 
 #include <util/formattinghelpers.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <KMessageBox>
 #include <interfaces/iuicontroller.h>
 #include <KParts/MainWindow>
 #include <KLocalizedString>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <util/path.h>
 #include <debug.h>
 
 using namespace KDevelop;
 
 static QPointer<CustomScriptPlugin> indentPluginSingleton;
 
 K_PLUGIN_FACTORY_WITH_JSON(CustomScriptFactory, "kdevcustomscript.json", registerPlugin<CustomScriptPlugin>(); )
 
 // Replaces ${KEY} in command with variables[KEY]
-static QString replaceVariables(QString command, QMap<QString, QString> variables)
+static QString replaceVariables(QString command, const QMap<QString, QString>& variables)
 {
     while (command.contains(QLatin1String("${"))) {
         int pos = command.indexOf(QLatin1String("${"));
         int end = command.indexOf(QLatin1Char('}'), pos + 2);
         if (end == -1) {
             break;
         }
         QString key = command.mid(pos + 2, end - pos - 2);
 
         const auto variableIt = variables.constFind(key);
         if (variableIt != variables.constEnd()) {
             command.replace(pos, 1 + end - pos, *variableIt );
         } else {
             qCDebug(CUSTOMSCRIPT) << "found no variable while replacing in shell-command" << command << "key" << key << "available:" << variables;
             command.remove(pos, 1 + end - pos);
         }
     }
     return command;
 }
 
 CustomScriptPlugin::CustomScriptPlugin(QObject* parent, const QVariantList&)
     : IPlugin(QStringLiteral("kdevcustomscript"), parent)
 {
     m_currentStyle = predefinedStyles().at(0);
     indentPluginSingleton = this;
 }
 
 CustomScriptPlugin::~CustomScriptPlugin()
 {
 }
 
 QString CustomScriptPlugin::name() const
 {
     // This needs to match the X-KDE-PluginInfo-Name entry from the .desktop file!
     return QStringLiteral("kdevcustomscript");
 }
 
 QString CustomScriptPlugin::caption() const
 {
     return QStringLiteral("Custom Script Formatter");
 }
 
 QString CustomScriptPlugin::description() const
 {
     return i18n("<b>Indent and Format Source Code.</b><br />"
                 "This plugin allows using powerful external formatting tools "
                 "that can be invoked through the command-line.<br />"
                 "For example, the <b>uncrustify</b>, <b>astyle</b> or <b>indent</b> "
                 "formatters can be used.<br />"
                 "The advantage of command-line formatters is that formatting configurations "
                 "can be easily shared by all team members, independent of their preferred IDE.");
 }
 
 QString CustomScriptPlugin::formatSourceWithStyle(SourceFormatterStyle style, const QString& text, const QUrl& url, const QMimeType& /*mime*/, const QString& leftContext, const QString& rightContext) const
 {
     KProcess proc;
     QTextStream ios(&proc);
 
     std::unique_ptr<QTemporaryFile> tmpFile;
 
     if (style.content().isEmpty()) {
         style = predefinedStyle(style.name());
         if (style.content().isEmpty()) {
             qCWarning(CUSTOMSCRIPT) << "Empty contents for style" << style.name() << "for indent plugin";
             return text;
         }
     }
 
     QString useText = text;
     useText = leftContext + useText + rightContext;
 
     QMap<QString, QString> projectVariables;
     const auto projects = ICore::self()->projectController()->projects();
     for (IProject* project : projects) {
         projectVariables[project->name()] = project->path().toUrl().toLocalFile();
     }
 
     QString command = style.content();
 
     // Replace ${Project} with the project path
     command = replaceVariables(command, projectVariables);
     command.replace(QLatin1String("$FILE"), url.toLocalFile());
 
     if (command.contains(QLatin1String("$TMPFILE"))) {
         tmpFile.reset(new QTemporaryFile(QDir::tempPath() + QLatin1String("/code")));
         tmpFile->setAutoRemove(false);
         if (tmpFile->open()) {
             qCDebug(CUSTOMSCRIPT) << "using temporary file" << tmpFile->fileName();
             command.replace(QLatin1String("$TMPFILE"), tmpFile->fileName());
             QByteArray useTextArray = useText.toLocal8Bit();
             if (tmpFile->write(useTextArray) != useTextArray.size()) {
                 qCWarning(CUSTOMSCRIPT) << "failed to write text to temporary file";
                 return text;
             }
         } else {
             qCWarning(CUSTOMSCRIPT) << "Failed to create a temporary file";
             return text;
         }
         tmpFile->close();
     }
 
     qCDebug(CUSTOMSCRIPT) << "using shell command for indentation: " << command;
     proc.setShellCommand(command);
     proc.setOutputChannelMode(KProcess::OnlyStdoutChannel);
 
     proc.start();
     if (!proc.waitForStarted()) {
         qCDebug(CUSTOMSCRIPT) << "Unable to start indent" << endl;
         return text;
     }
 
     if (!tmpFile.get()) {
         proc.write(useText.toLocal8Bit());
     }
 
     proc.closeWriteChannel();
     if (!proc.waitForFinished()) {
         qCDebug(CUSTOMSCRIPT) << "Process doesn't finish" << endl;
         return text;
     }
 
     QString output;
 
     if (tmpFile.get()) {
         QFile f(tmpFile->fileName());
         if (f.open(QIODevice::ReadOnly)) {
             output = QString::fromLocal8Bit(f.readAll());
         } else {
             qCWarning(CUSTOMSCRIPT) << "Failed opening the temporary file for reading";
             return text;
         }
     } else {
         output = ios.readAll();
     }
     if (output.isEmpty()) {
         qCWarning(CUSTOMSCRIPT) << "indent returned empty text for style" << style.name() << style.content();
         return text;
     }
 
     int tabWidth = 4;
     if ((!leftContext.isEmpty() || !rightContext.isEmpty()) && (text.contains(QLatin1Char('	')) || output.contains(QLatin1Char('\t')))) {
         // If we have to do contex-matching with tabs, determine the correct tab-width so that the context
         // can be matched correctly
         Indentation indent = indentation(url);
         if (indent.indentationTabWidth > 0) {
             tabWidth = indent.indentationTabWidth;
         }
     }
 
     return KDevelop::extractFormattedTextFromContext(output, text, leftContext, rightContext, tabWidth);
 }
 
 QString CustomScriptPlugin::formatSource(const QString& text, const QUrl& url, const QMimeType& mime, const QString& leftContext, const QString& rightContext) const
 {
 	auto style = KDevelop::ICore::self()->sourceFormatterController()->styleForUrl(url, mime);
     return formatSourceWithStyle(style, text, url, mime, leftContext, rightContext);
 }
 
 static QVector<SourceFormatterStyle> stylesFromLanguagePlugins()
 {
     QVector<KDevelop::SourceFormatterStyle> styles;
     const auto loadedLanguages = ICore::self()->languageController()->loadedLanguages();
     for (auto* lang : loadedLanguages) {
         const SourceFormatterItemList& languageStyles = lang->sourceFormatterItems();
         for (const SourceFormatterStyleItem& item: languageStyles) {
             if (item.engine == QLatin1String("customscript")) {
                 styles << item.style;
             }
         }
     }
 
     return styles;
 }
 
 KDevelop::SourceFormatterStyle CustomScriptPlugin::predefinedStyle(const QString& name) const
 {
 	const auto& langStyles = stylesFromLanguagePlugins();
     for (auto& langStyle: langStyles) {
         qCDebug(CUSTOMSCRIPT) << "looking at style from language with custom sample" << langStyle.description() << langStyle.overrideSample();
         if (langStyle.name() == name) {
             return langStyle;
         }
     }
 
     SourceFormatterStyle result(name);
     if (name == QLatin1String("GNU_indent_GNU")) {
         result.setCaption(i18n("Gnu Indent: GNU"));
         result.setContent(QStringLiteral("indent"));
         result.setUsePreview(true);
     } else if (name == QLatin1String("GNU_indent_KR")) {
         result.setCaption(i18n("Gnu Indent: Kernighan & Ritchie"));
         result.setContent(QStringLiteral("indent -kr"));
         result.setUsePreview(true);
     } else if (name == QLatin1String("GNU_indent_orig")) {
         result.setCaption(i18n("Gnu Indent: Original Berkeley indent style"));
         result.setContent(QStringLiteral("indent -orig"));
         result.setUsePreview(true);
     } else if (name == QLatin1String("kdev_format_source")) {
         result.setCaption(QStringLiteral("KDevelop: kdev_format_source"));
         result.setContent(QStringLiteral("kdev_format_source $FILE $TMPFILE"));
         result.setUsePreview(false);
         result.setDescription(i18n("Description:<br />"
                                    "<b>kdev_format_source</b> is a script bundled with KDevelop "
                                    "which allows using fine-grained formatting rules by placing "
                                    "meta-files called <b>format_sources</b> into the file-system.<br /><br />"
                                    "Each line of the <b>format_sources</b> files defines a list of wildcards "
                                    "followed by a colon and the used formatting-command.<br /><br />"
                                    "The formatting-command should use <b>$TMPFILE</b> to reference the "
                                    "temporary file to reformat.<br /><br />"
                                    "Example:<br />"
                                    "<b>*.cpp *.h : myformatter $TMPFILE</b><br />"
                                    "This will reformat all files ending with <b>.cpp</b> or <b>.h</b> using "
                                    "the custom formatting script <b>myformatter</b>.<br /><br />"
                                    "Example: <br />"
                                    "<b>subdir/* : uncrustify -l CPP -f $TMPFILE -c uncrustify.config -o $TMPFILE</b> <br />"
                                    "This will reformat all files in subdirectory <b>subdir</b> using the <b>uncrustify</b> "
                                    "tool with the config-file <b>uncrustify.config</b>."));
     }
     result.setMimeTypes({
         {QStringLiteral("text/x-c++src"), QStringLiteral("C++")},
         {QStringLiteral("text/x-chdr"),   QStringLiteral("C")},
         {QStringLiteral("text/x-c++hdr"), QStringLiteral("C++")},
         {QStringLiteral("text/x-csrc"),   QStringLiteral("C")},
         {QStringLiteral("text/x-java"),   QStringLiteral("Java")},
         {QStringLiteral("text/x-csharp"), QStringLiteral("C#")},
         {QStringLiteral("text/x-objcsrc"), QStringLiteral("Objective-C")},
         {QStringLiteral("text/x-objc++src"), QStringLiteral("Objective-C++")},
         {QStringLiteral("text/x-objchdr"), QStringLiteral("Objective-C")},
     });
     return result;
 }
 
 QVector<KDevelop::SourceFormatterStyle> CustomScriptPlugin::predefinedStyles() const
 {
     const QVector<KDevelop::SourceFormatterStyle> styles = stylesFromLanguagePlugins() + QVector<KDevelop::SourceFormatterStyle>{
         predefinedStyle(QStringLiteral("kdev_format_source")),
         predefinedStyle(QStringLiteral("GNU_indent_GNU")),
         predefinedStyle(QStringLiteral("GNU_indent_KR")),
         predefinedStyle(QStringLiteral("GNU_indent_orig")),
     };
     return styles;
 }
 
 KDevelop::SettingsWidget* CustomScriptPlugin::editStyleWidget(const QMimeType& mime) const
 {
     Q_UNUSED(mime);
     return new CustomScriptPreferences();
 }
 
 static QString formattingSample()
 {
     return QStringLiteral(
         "// Formatting\n"
         "void func(){\n"
         "\tif(isFoo(a,b))\n"
         "\tbar(a,b);\n"
         "if(isFoo)\n"
         "\ta=bar((b-c)*a,*d--);\n"
         "if(  isFoo( a,b ) )\n"
         "\tbar(a, b);\n"
         "if (isFoo) {isFoo=false;cat << isFoo <<endl;}\n"
         "if(isFoo)DoBar();if (isFoo){\n"
         "\tbar();\n"
         "}\n"
         "\telse if(isBar()){\n"
         "\tannotherBar();\n"
         "}\n"
         "int var = 1;\n"
         "int *ptr = &var;\n"
         "int &ref = i;\n"
         "\n"
         "QList<int>::const_iterator it = list.begin();\n"
         "}\n"
         "namespace A {\n"
         "namespace B {\n"
         "void foo() {\n"
         "  if (true) {\n"
         "    func();\n"
         "  } else {\n"
         "    // bla\n"
         "  }\n"
         "}\n"
         "}\n"
         "}\n");
 }
 
 static QString indentingSample()
 {
     return QStringLiteral(
         "// Indentation\n"
         "#define foobar(A)\\\n"
         "{Foo();Bar();}\n"
         "#define anotherFoo(B)\\\n"
         "return Bar()\n"
         "\n"
         "namespace Bar\n"
         "{\n"
         "class Foo\n"
         "{public:\n"
         "Foo();\n"
         "virtual ~Foo();\n"
         "};\n"
         "void bar(int foo)\n"
         "{\n"
         "switch (foo)\n"
         "{\n"
         "case 1:\n"
         "a+=1;\n"
         "break;\n"
         "case 2:\n"
         "{\n"
         "a += 2;\n"
         " break;\n"
         "}\n"
         "}\n"
         "if (isFoo)\n"
         "{\n"
         "bar();\n"
         "}\n"
         "else\n"
         "{\n"
         "anotherBar();\n"
         "}\n"
         "}\n"
         "int foo()\n"
         "\twhile(isFoo)\n"
         "\t\t{\n"
         "\t\t\t// ...\n"
         "\t\t\tgoto error;\n"
         "\t\t/* .... */\n"
         "\t\terror:\n"
         "\t\t\t//...\n"
         "\t\t}\n"
         "\t}\n"
         "fooArray[]={ red,\n"
         "\tgreen,\n"
         "\tdarkblue};\n"
         "fooFunction(barArg1,\n"
         "\tbarArg2,\n"
         "\tbarArg3);\n"
         );
 }
 
 QString CustomScriptPlugin::previewText(const SourceFormatterStyle& style, const QMimeType& /*mime*/) const
 {
     if (!style.overrideSample().isEmpty()) {
         return style.overrideSample();
     }
     return formattingSample() + QLatin1String("\n\n") + indentingSample();
 }
 
 QStringList CustomScriptPlugin::computeIndentationFromSample(const QUrl& url) const
 {
     QStringList ret;
 
     auto languages = ICore::self()->languageController()->languagesForUrl(url);
     if (languages.isEmpty()) {
         return ret;
     }
 
     QString sample = languages[0]->indentationSample();
     QString formattedSample = formatSource(sample, url, QMimeDatabase().mimeTypeForUrl(url), QString(), QString());
 
     const QStringList lines = formattedSample.split(QLatin1Char('\n'));
     for (const QString& line : lines) {
         if (!line.isEmpty() && line[0].isSpace()) {
             QString indent;
             for (const QChar c : line) {
                 if (c.isSpace()) {
                     indent.push_back(c);
                 } else {
                     break;
                 }
             }
 
             if (!indent.isEmpty() && !ret.contains(indent)) {
                 ret.push_back(indent);
             }
         }
     }
 
     return ret;
 }
 
 CustomScriptPlugin::Indentation CustomScriptPlugin::indentation(const QUrl& url) const
 {
     Indentation ret;
     QStringList indent = computeIndentationFromSample(url);
     if (indent.isEmpty()) {
         qCDebug(CUSTOMSCRIPT) << "failed extracting a valid indentation from sample for url" << url;
         return ret; // No valid indentation could be extracted
     }
 
     if (indent[0].contains(QLatin1Char(' '))) {
         ret.indentWidth = indent[0].count(QLatin1Char(' '));
     }
 
     if (!indent.join(QString()).contains(QLatin1Char('	'))) {
         ret.indentationTabWidth = -1;         // Tabs are not used for indentation
     }
     if (indent[0] == QLatin1String("	")) {
         // The script indents with tabs-only
         // The problem is that we don't know how
         // wide a tab is supposed to be.
         //
         // We need indentation-width=tab-width
         // to make the editor do tab-only formatting,
         // so choose a random with of 4.
         ret.indentWidth = 4;
         ret.indentationTabWidth = 4;
     } else if (ret.indentWidth)   {
         // Tabs are used for indentation, alongside with spaces
         // Try finding out how many spaces one tab stands for.
         // Do it by assuming a uniform indentation-step with each level.
 
         for (int pos = 0; pos < indent.size(); ++pos) {
             if (indent[pos] == QLatin1String("	")&& pos >= 1) {
                 // This line consists of only a tab.
                 int prevWidth = indent[pos - 1].length();
                 int prevPrevWidth = (pos >= 2) ? indent[pos - 2].length() : 0;
                 int step = prevWidth - prevPrevWidth;
                 qCDebug(CUSTOMSCRIPT) << "found in line " << pos << prevWidth << prevPrevWidth << step;
                 if (step > 0 && step <= prevWidth) {
                     qCDebug(CUSTOMSCRIPT) << "Done";
                     ret.indentationTabWidth = prevWidth + step;
                     break;
                 }
             }
         }
     }
 
     qCDebug(CUSTOMSCRIPT) << "indent-sample" << QLatin1Char('\"') + indent.join(QLatin1Char('\n')) + QLatin1Char('\"') << "extracted tab-width" << ret.indentationTabWidth << "extracted indentation width" << ret.indentWidth;
 
     return ret;
 }
 
 void CustomScriptPreferences::updateTimeout()
 {
     const QString& text = indentPluginSingleton.data()->previewText(m_style, QMimeType());
     QString formatted = indentPluginSingleton.data()->formatSourceWithStyle(m_style, text, QUrl(), QMimeType());
     emit previewTextChanged(formatted);
 }
 
 CustomScriptPreferences::CustomScriptPreferences()
 {
     m_updateTimer = new QTimer(this);
     m_updateTimer->setSingleShot(true);
     m_updateTimer->setInterval(1000);
     connect(m_updateTimer, &QTimer::timeout, this, &CustomScriptPreferences::updateTimeout);
     m_vLayout = new QVBoxLayout(this);
     m_vLayout->setMargin(0);
     m_captionLabel = new QLabel;
     m_vLayout->addWidget(m_captionLabel);
     m_vLayout->addSpacing(10);
     m_hLayout = new QHBoxLayout;
     m_vLayout->addLayout(m_hLayout);
     m_commandLabel = new QLabel;
     m_hLayout->addWidget(m_commandLabel);
     m_commandEdit = new QLineEdit;
     m_hLayout->addWidget(m_commandEdit);
     m_commandLabel->setText(i18n("Command:"));
     m_vLayout->addSpacing(10);
     m_bottomLabel = new QLabel;
     m_vLayout->addWidget(m_bottomLabel);
     m_bottomLabel->setTextFormat(Qt::RichText);
     m_bottomLabel->setText(
         i18n("<i>You can enter an arbitrary shell command.</i><br />"
              "The unformatted source-code is reached to the command <br />"
              "through the standard input, and the <br />"
              "formatted result is read from the standard output.<br />"
              "<br />"
              "If you add <b>$TMPFILE</b> into the command, then <br />"
              "a temporary file is used for transferring the code."));
     connect(m_commandEdit, &QLineEdit::textEdited,
             m_updateTimer, QOverload<>::of(&QTimer::start));
 
     m_vLayout->addSpacing(10);
 
     m_moreVariablesButton = new QPushButton(i18n("More Variables"));
     connect(m_moreVariablesButton, &QPushButton::clicked, this, &CustomScriptPreferences::moreVariablesClicked);
     m_vLayout->addWidget(m_moreVariablesButton);
     m_vLayout->addStretch();
 }
 
 void CustomScriptPreferences::load(const KDevelop::SourceFormatterStyle& style)
 {
     m_style = style;
     m_commandEdit->setText(style.content());
     m_captionLabel->setText(i18n("Style: %1", style.caption()));
 
     updateTimeout();
 }
 
 QString CustomScriptPreferences::save()
 {
     return m_commandEdit->text();
 }
 
 void CustomScriptPreferences::moreVariablesClicked(bool)
 {
     KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                              i18n("<b>$TMPFILE</b> will be replaced with the path to a temporary file. <br />"
                                   "The code will be written into the file, the temporary <br />"
                                   "file will be substituted into that position, and the result <br />"
                                   "will be read out of that file. <br />"
                                   "<br />"
                                   "<b>$FILE</b> will be replaced with the path of the original file. <br />"
                                   "The contents of the file must not be modified, changes are allowed <br />"
                                   "only in $TMPFILE.<br />"
                                   "<br />"
                                   "<b>${PROJECT_NAME}</b> will be replaced by the path of <br />"
                                   "the currently open project with the matching name."
 
                                   ), i18n("Variable Replacements"));
 }
 
 #include "customscript_plugin.moc"