Differential D22144 Diff 64406 recentlyused/recentlyused.cpp

Changeset View

Standalone View

View Options

recentlyused/recentlyused.cpp

  • This file was added.
1​/*
2​ * Copyright (C) 2019 Méven Car <meven.car@kdemail.net>
3​ *
4​ * This library is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU Lesser General Public
6​ * License as published by the Free Software Foundation; either
7​ * version 2.1 of the License, or (at your option) version 3, or any
8​ * later version accepted by the membership of KDE e.V. (or its
9​ * successor approved by the membership of KDE e.V.), which shall
10​ * act as a proxy defined in Section 6 of version 3 of the license.
11​ *
12​ * This library is distributed in the hope that it will be useful,
13​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​ * Lesser General Public License for more details.
16​ *
17​ * You should have received a copy of the GNU Lesser General Public
18​ * License along with this library.
19​ * If not, see <http://www.gnu.org/licenses/>.
20​ */
21​
22​#include "recentlyused-logsettings.h"
23​#include "recentlyused.h"
24​
25​#include <QCoreApplication>
26​#include <QDBusInterface>
27​#include <QFileInfo>
28​#include <QUrl>
29​#include <QUrlQuery>
ngrahamUnsubmitted
Done

Remove

ngraham: Remove
30​#include <QString>
31​
32​#include <KRecentDocument>
33​#include <KDirWatch>
34​#include <KDesktopFile>
35​#include <KIO/Job>
36​#include <KLocalizedString>
37​#include <KProtocolManager>
38​
39​#include <stdio.h>
40​
41​#include <KActivities/Stats/Cleaning>
42​#include <KActivities/Stats/ResultModel>
43​#include <KActivities/Stats/Terms>
44​
45​namespace KAStats = KActivities::Stats;
46​
47​using namespace KAStats;
48​using namespace KAStats::Terms;
49​
50​// Pseudo plugin class to embed meta data
51​class KIOPluginForMetaData : public QObject
52​{
53​ Q_OBJECT
54​ Q_PLUGIN_METADATA(IID "org.kde.kio.slave.recentlyused" FILE "recentlyused.json")
55​};
56​
57​extern "C" int Q_DECL_EXPORT kdemain(int argc, char **argv)
58​{
59​ // necessary to use other kio slaves
60​ QCoreApplication app(argc, argv);
61​ app.setApplicationName(QStringLiteral("kio_recentlyused"));
62​ if (argc != 4) {
63​ fprintf(stderr, "Usage: kio_recentlyused protocol domain-socket1 domain-socket2\n");
64​ exit(-1);
65​ }
66​ // start the slave
67​ RecentlyUsed slave(argv[2], argv[3]);
68​ slave.dispatchLoop();
69​ return 0;
70​}
71​
72​static bool isRootUrl(const QUrl &url)
73​{
dfaureUnsubmitted
Done

prepend "static"

dfaure: prepend "static"
74​ const QString path = url.adjusted(QUrl::StripTrailingSlash).path();
75​ return path.isEmpty() || path == QLatin1String("/");
76​}
77​
78​RecentlyUsed::RecentlyUsed(const QByteArray &pool, const QByteArray &app)
79​ : ForwardingSlaveBase("recentlyused", pool, app)
80​{
81​}
82​
83​RecentlyUsed::~RecentlyUsed()
84​{
85​}
86​
87​bool RecentlyUsed::rewriteUrl(const QUrl &url, QUrl &newUrl)
88​{
89​ Q_UNUSED(url);
90​ Q_UNUSED(newUrl);
91​ return false;
92​}
dfaureUnsubmitted
Done

I may be missing something, but if you don't really reimplement rewriteUrl, then what's the point of using ForwardingSlaveBase in the first place, instead of just SlaveBase?

IIRC *all* of ForwardingSlaveBase's code is based on the rewriteUrl idea.

dfaure: I may be missing something, but if you don't really reimplement rewriteUrl, then what's the…
mevenAuthorUnsubmitted
Done

I started my work upon the recentdocument ioslave that used it and ForwardingSlaveBase documentation states "It has been designed to support only local filesystem like ioslaves.. If the resulting ioslave should be a simple proxy, you only need to implement the ForwardingSlaveBase::rewriteUrl() method." makes it sound like that is what I needed.
Using SlaveBase would need a lot more code added also that I don't particularly need to implement here.
But please correct me.

meven: I started my work upon the recentdocument ioslave that used it and ForwardingSlaveBase…
dfaureUnsubmitted
Done

I'm confused. Which code from ForwardingSlaveBase is this class benefiting from?
With internalRewriteUrl returning false all SlaveBase reimplementations in that class do nothing,

If you decide not to support listing/stat'ing subdirs then indeed you don't need ForwardingSlaveBase as base class.

dfaure: I'm confused. Which code from ForwardingSlaveBase is this class benefiting from? With…
mevenAuthorUnsubmitted
Done

After more testing, inheriting from ForwardSlaveBase was not needed.

meven: After more testing, inheriting from ForwardSlaveBase was not needed.
93​
94​ResultModel *runQuery(const QUrl &url)
95​{
96​ qCDebug(KIO_RECENTLYUSED_LOG) << "runQuery for url" << url.toString();
97​
98​ auto query = UsedResources
99​ | Limit(30);
100​
101​ // Parse url query parameter
102​ auto urlQuery = QUrlQuery(url);
103​
104​ // handles type aka mimetype
105​ if (urlQuery.hasQueryItem(QStringLiteral("type"))) {
106​ auto typeValue = urlQuery.queryItemValue(QStringLiteral("type"));
107​ auto types = typeValue.split(QLatin1Char(','));
108​ if (types.count() == 1) {
109​ query = query | Type(typeValue);
110​ } else {
dfaureUnsubmitted
Done

(hmm, someone should implement operator |= in kactivities-stat, to make such code simpler and possibly faster)

dfaure: (hmm, someone should implement operator |= in kactivities-stat, to make such code simpler and…
mevenAuthorUnsubmitted
Done

Tried implementing this in D23372 but @ivan was not found of it because of induced complexity it entails to work properly.

meven: Tried implementing this in D23372 but @ivan was not found of it because of induced complexity…
ivanUnsubmitted
Done

Also, there are set* and add* member functions which can be used for non-chained changes.

ivan: Also, there are `set*` and `add*` member functions which can be used for non-chained changes.
mevenAuthorUnsubmitted
Done

We don't have yet set function for Activity, Type, Agent, and Url only add.
Which means we would need to use query.addActivity(QStringList() << ":any")) sometimes for instance, that is not ideal since it makes the user class use internal details such as ":any".
I would be in favor to add setActivity(Terms::Activity) in KactivitiesStats same for Type, Agent and Url, to get arount that and maybe also addActivity(Terms::Activity) as well for consistency.

meven: We don't have yet set function for Activity, Type, Agent, and Url only add. Which means we…
ivanUnsubmitted
Done

You have Activity::any() - no need for the client to use the special values. You can do a addActivities({Activity::any()}).

I would not mind to add set* variants of add* functions - setActivities, setTypes, etc. to avoid the need of calling clear* and then add*.

I'm also thinking whether it would be useful to have a variadic template versions of these so that you can skip the QList<T> construction. That might be better to wait for Qt 6 and raised C++ version requirement. Not sure.

ivan: You have `Activity::any()` - no need for the client to use the special values. You can do a…
111​ // multiple mimetypes were passed
112​ query = query | Type(types);
113​ }
114​ }
115​
116​ // limit parameter
117​ if (urlQuery.hasQueryItem(QStringLiteral("limit"))) {
118​ auto limitValue = urlQuery.queryItemValue(QStringLiteral("limit"));
119​ bool parseOk;
120​ auto limitInt = limitValue.toInt(&parseOk);
121​ if (parseOk) {
122​ query = query | Limit(limitInt);
123​ }
124​ }
125​
126​ // activity parameter, filter using the uuid of the activity
127​ if (urlQuery.hasQueryItem(QStringLiteral("activity"))) {
128​ auto activityValue = urlQuery.queryItemValue(QStringLiteral("activity"));
129​ if (activityValue == QStringLiteral("any")) {
130​ query = query | Activity::any();
131​ } else {
132​ query = query | Activity(activityValue);
133​ }
134​ } else {
135​ query = query | Activity::current();
136​ }
137​
138​ // date parameter, filter using the date when an event occured on a resource
139​ if (urlQuery.hasQueryItem(QStringLiteral("date"))) {
140​ auto dateValue = urlQuery.queryItemValue(QStringLiteral("date"));
141​ if (dateValue == QStringLiteral("today")) {
142​ query = query | Date::today();
143​ } else if (dateValue == QStringLiteral("yesterday")) {
144​ query = query | Date::yesterday();
ngrahamUnsubmitted
Done

Missing a space before else if

ngraham: Missing a space before `else if`
145​ } else {
ivanUnsubmitted
Done

Could this just be replaced with query = query | Agent(agentValue.split(QLatin1Char(',')));?

Obviously, the downside is always creating a list (usually with a single item in it), the upside is that it does not need to traverse the string twice (once to chech for commas, and the second time to split the string.

The trade-off depends on internals of Qt - if you don't have the time to benchmark what is faster, leave it as is.

ivan: Could this just be replaced with `query = query | Agent(agentValue.split(QLatin1Char(',')));`?
mevenAuthorUnsubmitted
Done

I have used count() as it allows not to keep the list in memory if not needed.
Same was done for the type parameter.

meven: I have used count() as it allows not to keep the list in memory if not needed. Same was done…
146​ query = query | Date::fromString(dateValue);
147​ }
148​ }
149​
150​ // agent parameter, filter using the application name that used the resource
151​ if (urlQuery.hasQueryItem(QStringLiteral("agent"))) {
152​ auto agentValue = urlQuery.queryItemValue(QStringLiteral("agent"));
153​ auto agents = agentValue.split(QLatin1Char(','));
154​ if (agents.count() == 1) {
155​ query = query | Agent(agentValue);
156​ } else {
157​ // multiple agents were passed
158​ query = query | Agent(agents);
159​ }
160​ } else {
161​ query = query | Agent::any();
162​ }
163​
164​ // url parameter for exact path match or folders, supports wildcard pattern matching
165​ if (urlQuery.hasQueryItem(QStringLiteral("url"))) {
166​ query = query | Url(urlQuery.queryItemValue(QStringLiteral("url")));
167​ } else {
168​ query = query | Url::file();
169​ }
170​
171​ // see KActivities::Stats::Terms::Order
172​ if (urlQuery.hasQueryItem(QStringLiteral("order"))) {
173​ auto orderValue = urlQuery.queryItemValue(QStringLiteral("order"));
174​
175​ if (orderValue == QStringLiteral("HighScoredFirst")) {
176​ query = query | Order::HighScoredFirst;
177​ } else if (orderValue == QStringLiteral("RecentlyCreatedFirst")) {
178​ query = query | Order::RecentlyCreatedFirst;
179​ } else if (orderValue == QStringLiteral("OrderByUrl")) {
180​ query = query | Order::OrderByUrl;
181​ } else if (orderValue == QStringLiteral("OrderByTitle")) {
182​ query = query | Order::OrderByTitle;
183​ } else {
184​ query = query | Order::RecentlyUsedFirst;
185​ }
186​ } else {
187​ query = query | Order::RecentlyUsedFirst;
dfaureUnsubmitted
Done

You don't need spaces between items, when using q[C]Debug

dfaure: You don't need spaces between items, when using q[C]Debug
188​ }
189​
190​ return new ResultModel(query);
191​}
192​
193​KIO::UDSEntry RecentlyUsed::udsEntryFromResource(const QString &resource)
194​{
195​ qCDebug(KIO_RECENTLYUSED_LOG) << "udsEntryFromResource" << " " << resource;
196​
197​ // the query only returns files and folders
198​ QUrl resourceUrl = QUrl::fromLocalFile(resource);
199​
200​ KIO::UDSEntry uds;
201​ KIO::StatJob *job = KIO::stat(resourceUrl, KIO::HideProgressInfo);
202​
203​ // we do not want to wait for the event loop to delete the job
204​ QScopedPointer<KIO::StatJob> sp(job);
205​ job->setAutoDelete(false);
206​ if (job->exec()) {
207​ uds = job->statResult();
208​ }
209​ uds.fastInsert(KIO::UDSEntry::UDS_URL, resourceUrl.toString());
210​ return uds;
211​}
212​
ngrahamUnsubmitted
Done

space after for

ngraham: space after `for`
213​void RecentlyUsed::listDir(const QUrl &url)
214​{
215​ if (!isRootUrl(url)) {
216​ error(KIO::ERR_DOES_NOT_EXIST, url.toDisplayString());
217​ return;
218​ }
219​
220​ auto model = runQuery(url);
221​
222​ KIO::UDSEntryList udslist;
223​ udslist.reserve(model->rowCount());
224​
225​ for (int r = 0; r < model->rowCount(); ++r) {
226​ QModelIndex index = model->index(r, 0);
227​ QString resource = model->data(index, ResultModel::ResourceRole).toString();
228​
229​ udslist << udsEntryFromResource(resource);
230​ }
231​
232​ listEntries(udslist);
233​ finished();
234​}
235​
236​void RecentlyUsed::stat(const QUrl &url)
237​{
238​ qCDebug(KIO_RECENTLYUSED_LOG) << "stating" << " " << url;
239​
240​ if (isRootUrl(url)) {
241​ //
242​ // stat the root path
243​ //
244​
245​ QString dirName = i18n("Recent Documents");
246​ KIO::UDSEntry uds;
dfaureUnsubmitted
Done

I count 6...

dfaure: I count 6...
247​ uds.reserve(6);
248​ uds.fastInsert(KIO::UDSEntry::UDS_NAME, dirName);
249​ uds.fastInsert(KIO::UDSEntry::UDS_DISPLAY_NAME, dirName);
250​ uds.fastInsert(KIO::UDSEntry::UDS_DISPLAY_TYPE, dirName);
251​ uds.fastInsert(KIO::UDSEntry::UDS_ICON_NAME, QStringLiteral("document-open-recent"));
ivanUnsubmitted
Done

QStringLiteral?

ivan: `QStringLiteral`?
252​ uds.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
253​ uds.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
254​
255​ statEntry(uds);
256​ finished();
257​ } else {
dfaureUnsubmitted
Done

Isn't that a problem? Any user of this ioslave might stat() a URL representing a file or directory, coming from this kioslave.

E.g. if you paste a URL of a subdir from one dolphin window to another, I suspect it will happen then. At least in konqueror it does, maybe dolphin assumes everything is a directory since it can't do much with a file URL....

dfaure: Isn't that a problem? Any user of this ioslave might stat() a URL representing a file or…
mevenAuthorUnsubmitted
Done

I implemented the kioslave to allow only stating and listing "/" path on purpose : I could not find a use case for subdirs.
I chose url parameters to pass pararmeters for simplicity albeit it makes it less appealing in UI as you cannot have subpath breaking down your parameters.
Any files or folders appearing in the ioslave keep their true urls.

meven: I implemented the kioslave to allow only stating and listing "/" path on purpose : I could not…
258​ // only the root path is supported
259​ error(KIO::ERR_DOES_NOT_EXIST, url.toDisplayString());
260​ }
261​}
262​
263​void RecentlyUsed::mimetype(const QUrl &url)
264​{
265​ // the root url is always a folder
266​ if (isRootUrl(url)) {
267​ mimeType(QStringLiteral("inode/directory"));
268​ finished();
269​ } else {
270​ // only the root path is supported
271​ error(KIO::ERR_DOES_NOT_EXIST, url.toDisplayString());
272​ }
273​}
274​
275​// needed for JSON file embedding
276​#include "recentlyused.moc"