Differential D14288 Diff 40026 plugins/clazy/jobparameters.cpp

Changeset View

Standalone View

View Options

plugins/clazy/jobparameters.cpp

  • This file was added.
1​/* This file is part of KDevelop
2​
3​ Copyright 2018 Anton Anikin <anton@anikin.xyz>
4​
5​ This program is free software; you can redistribute it and/or
6​ modify it under the terms of the GNU General Public
7​ License as published by the Free Software Foundation; either
8​ version 2 of the License, or (at your option) any later version.
9​
10​ This program is distributed in the hope that it will be useful,
11​ but WITHOUT ANY WARRANTY; without even the implied warranty of
12​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13​ General Public License for more details.
14​
15​ You should have received a copy of the GNU General Public License
16​ along with this program; see the file COPYING. If not, write to
17​ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18​ Boston, MA 02110-1301, USA.
19​*/
20​
21​#include "jobparameters.h"
22​
23​#include "debug.h"
24​#include "globalsettings.h"
25​#include "projectsettings.h"
26​#include "utils.h"
27​
28​#include <interfaces/iproject.h>
29​#include <serialization/indexedstring.h>
30​#include <project/interfaces/ibuildsystemmanager.h>
31​#include <project/projectmodel.h>
32​
33​#include <KShell>
34​#include <KLocalizedString>
35​
36​#include <QDir>
37​#include <QStandardPaths>
38​
39​namespace Clazy
40​{
41​
42​JobGlobalParameters::JobGlobalParameters()
43​ : JobGlobalParameters(GlobalSettings::executablePath(), GlobalSettings::docsPath())
44​{
45​}
46​
47​JobGlobalParameters::JobGlobalParameters(const QUrl& executablePath, const QUrl& docsPath)
48​{
49​ m_executablePath = executablePath.toLocalFile();
50​ m_docsPath = docsPath.toLocalFile();
51​
52​ QFileInfo info;
53​
54​ if (m_executablePath.isEmpty()) {
55​ if (defaultExecutablePath().toLocalFile().isEmpty()) {
56​ m_error = i18n(
57​ "clazy-standalone path cannot be detected. "
58​ "Set the path manually if clazy is already installed.");
59​ } else {
60​ m_error = i18n("clazy-standalone path is empty.");
61​ }
62​ return;
63​ }
64​
65​ info.setFile(m_executablePath);
66​
67​ if (!info.exists()) {
68​ m_error = i18n("clazy-standalone path '%1' does not exists.", m_executablePath);
69​ return;
70​ }
71​
72​ if (!info.isFile() || !info.isExecutable()) {
73​ m_error = i18n("clazy-standalone path '%1' is not an executable.", m_executablePath);
74​ return;
75​ }
76​
77​ // =============================================================================================
78​
79​ if (m_docsPath.isEmpty()) {
80​ if (defaultDocsPath().toLocalFile().isEmpty()) {
81​ m_error = i18n(
82​ "clazy docs path cannot be detected. "
83​ "Set the path manually if clazy is already installed.");
84​ } else {
85​ m_error = i18n("clazy docs path is empty.");
86​ }
87​ return;
88​ }
89​
90​ info.setFile(m_docsPath);
91​
92​ if (!info.exists()) {
93​ m_error = i18n("clazy docs path '%1' does not exists", m_docsPath);
94​ return;
95​ }
96​
97​ if (!info.isDir()) {
98​ m_error = i18n("clazy docs path '%1' is not a directory", m_docsPath);
99​ return;
100​ }
101​
102​ m_error.clear();
103​}
104​
105​QUrl JobGlobalParameters::defaultExecutablePath()
106​{
107​ return QUrl::fromLocalFile(QStandardPaths::findExecutable(QStringLiteral("clazy-standalone")));
108​}
109​
110​QUrl JobGlobalParameters::defaultDocsPath()
111​{
112​ const auto dataPaths = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
kossebauUnsubmitted
Done

Why not using QStandardPaths::locate()?

kossebau: Why not using QStandardPaths::locate()?
113​ for (const auto& dataPath : dataPaths)
114​ {
115​ QDir clazyDir(dataPath);
116​ if (!clazyDir.cd(QStringLiteral("clazy/doc"))) {
117​ continue;
118​ }
119​
120​ return QUrl::fromLocalFile(clazyDir.canonicalPath());
121​ }
122​
123​ return {};
124​}
125​
126​bool JobGlobalParameters::isValid() const
127​{
128​ return m_error.isEmpty();
129​}
130​
131​QString JobGlobalParameters::error() const
132​{
133​ return m_error;
134​}
135​
136​JobParameters::JobParameters(KDevelop::IProject* project)
137​ : JobParameters(project, QString())
138​{
139​}
140​
141​inline QString spaceEscapedPath(const QString& path)
142​{
143​ return QString(path).replace(QLatin1Char(' '), QLatin1String("\\ "));
144​}
145​
146​JobParameters::JobParameters(KDevelop::IProject* project, const QString& checkPath)
147​ : m_checkPath(checkPath)
148​{
149​ Q_ASSERT(project);
150​
151​ auto projectRootPath = project->path().toLocalFile();
152​
153​ auto buildPath = project->buildSystemManager()->buildDirectory(project->projectItem());
154​ m_projectBuildPath = buildPath.toLocalFile();
155​
156​ buildPath.addPath(QStringLiteral("compile_commands.json"));
pinoUnsubmitted
Done

"exist"

pino: "exist"
157​
158​ auto commandsFilePath = buildPath.toLocalFile();
159​ if (!QFile::exists(commandsFilePath)) {
160​ m_error = i18n("%1 does not exist", commandsFilePath);
161​ return;
162​ }
163​
164​ if (!m_checkPath.isEmpty()) {
165​ const auto allFiles = compileCommandsFiles(commandsFilePath, m_error);
166​ if (!m_error.isEmpty()) {
167​ return;
168​ }
169​
170​ if (m_checkPath == projectRootPath) {
171​ m_sources = allFiles;
172​ } else {
173​ const bool checkPathIsFile = QFileInfo(m_checkPath).isFile();
174​ for (auto& file : allFiles) {
175​ if (checkPathIsFile) {
176​ if (file == m_checkPath) {
177​ m_sources.clear();
178​ m_sources += m_checkPath;
179​ break;
180​ }
181​ } else if (file.startsWith(m_checkPath)) {
182​ m_sources += file;
183​ }
184​ }
185​ }
186​ }
187​
188​ for (QString& source : m_sources) {
189​ source = spaceEscapedPath(source);
190​ }
191​
192​ ProjectSettings projectSettings;
193​ projectSettings.setSharedConfig(project->projectConfiguration());
194​ projectSettings.load();
195​
196​ {
197​ // blocks changed() signal from setters
198​ QSignalBlocker blocker(this);
199​
200​ setChecks(projectSettings.checks());
201​
202​ setOnlyQt(projectSettings.onlyQt());
203​ setQtDeveloper(projectSettings.qtDeveloper());
204​ setQt4Compat(projectSettings.qt4Compat());
205​ setVisitImplicitCode(projectSettings.visitImplicitCode());
206​
207​ setIgnoreIncludedFiles(projectSettings.ignoreIncludedFiles());
208​ setHeaderFilter(projectSettings.headerFilter());
209​
210​ setEnableAllFixits(projectSettings.enableAllFixits());
211​ setNoInplaceFixits(projectSettings.noInplaceFixits());
212​
213​ setExtraAppend(projectSettings.extraAppend());
214​ setExtraPrepend(projectSettings.extraPrepend());
215​ setExtraClazy(projectSettings.extraClazy());
216​ }
217​
218​ if (m_sources.isEmpty()) {
219​ m_error = i18n("Nothing to check: %1 contains no matching items", commandsFilePath);
220​ }
221​}
222​
223​QString JobParameters::defaultChecks()
224​{
225​ return QStringLiteral("level1");
226​}
227​
228​QString JobParameters::checkPath() const
229​{
230​ return m_checkPath;
231​}
232​
233​const QStringList& JobParameters::sources() const
234​{
235​ return m_sources;
236​}
237​
238​QString JobParameters::projectBuildPath() const
239​{
240​ return m_projectBuildPath;
241​}
242​
243​QStringList JobParameters::commandLine() const
244​{
245​ QStringList arguments;
246​
247​ arguments << spaceEscapedPath(m_executablePath);
248​
249​ if (!m_checks.isEmpty()) {
250​ arguments << QStringLiteral("-checks=%1").arg(m_checks);
251​ }
252​
253​ if (m_onlyQt) {
254​ arguments << QStringLiteral("-only-qt");
255​ }
256​
257​ if (m_qtDeveloper) {
258​ arguments << QStringLiteral("-qt-developer");
259​ }
260​
261​ if (m_qt4Compat) {
262​ arguments << QStringLiteral("-qt4-compat");
263​ }
264​
265​ if (m_visitImplicitCode) {
266​ arguments << QStringLiteral("-visit-implicit-code");
267​ }
268​
269​ if (m_ignoreIncludedFiles) {
270​ arguments << QStringLiteral("-ignore-included-files");
271​ }
272​
273​ if (!m_headerFilter.isEmpty()) {
274​ arguments << QStringLiteral("-header-filter=%1").arg(m_headerFilter);
275​ }
276​
277​ if (m_enableAllFixits) {
278​ arguments << QStringLiteral("-enable-all-fixits");
279​ }
280​
281​ if (m_noInplaceFixits) {
282​ arguments << QStringLiteral("-no-inplace-fixits");
283​ }
284​
285​ if (!m_extraAppend.isEmpty()) {
286​ arguments << QStringLiteral("-extra-arg=%1").arg(m_extraAppend);
287​ }
288​
289​ if (!m_extraPrepend.isEmpty()) {
290​ arguments << QStringLiteral("-extra-arg-before=%1").arg(m_extraPrepend);
291​ }
292​
293​ if (!m_extraClazy.isEmpty()) {
294​ arguments << KShell::splitArgs(m_extraClazy);
295​ }
296​
297​ arguments << QStringLiteral("-p");
298​ arguments << spaceEscapedPath(m_projectBuildPath);
299​
300​ return arguments;
301​}
302​
303​
304​template<typename T>
305​void JobParameters::setValue(T& currentValue, const T& newValue)
306​{
307​ if (currentValue != newValue) {
308​ currentValue = newValue;
309​ emit changed();
310​ }
311​}
312​
313​void JobParameters::setChecks(const QString& checks)
314​{
315​ if (checks.isEmpty()) {
316​ setValue(m_checks, defaultChecks());
317​ } else {
318​ setValue(m_checks, checks);
319​ }
320​}
321​
322​void JobParameters::setOnlyQt(bool onlyQt)
323​{
324​ setValue(m_onlyQt, onlyQt);
325​}
326​
327​void JobParameters::setQtDeveloper(bool qtDeveloper)
328​{
329​ setValue(m_qtDeveloper, qtDeveloper);
330​}
331​
332​void JobParameters::setQt4Compat(bool qt4Compat)
333​{
334​ setValue(m_qt4Compat, qt4Compat);
335​}
336​
337​void JobParameters::setVisitImplicitCode(bool visitImplicitCode)
338​{
339​ setValue(m_visitImplicitCode, visitImplicitCode);
340​}
341​
342​void JobParameters::setIgnoreIncludedFiles(bool ignoreIncludedFiles)
343​{
344​ setValue(m_ignoreIncludedFiles, ignoreIncludedFiles);
345​}
346​
347​void JobParameters::setHeaderFilter(const QString& headerFilter)
348​{
349​ setValue(m_headerFilter, headerFilter);
350​}
351​
352​void JobParameters::setEnableAllFixits(bool enableAllFixits)
353​{
354​ setValue(m_enableAllFixits, enableAllFixits);
355​}
356​
357​void JobParameters::setNoInplaceFixits(bool noInplaceFixits)
358​{
359​ setValue(m_noInplaceFixits, noInplaceFixits);
360​}
361​
362​void JobParameters::setExtraAppend(const QString& extraAppend)
363​{
364​ setValue(m_extraAppend, extraAppend);
365​}
366​
367​void JobParameters::setExtraPrepend(const QString& extraPrepend)
368​{
369​ setValue(m_extraPrepend, extraPrepend);
370​}
371​
372​void JobParameters::setExtraClazy(const QString& extraClazy)
373​{
374​ setValue(m_extraClazy, extraClazy);
375​}
376​
377​}