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

prepend "static"

dfaure: prepend "static"
74​{
75​ const QString path = url.adjusted(QUrl::StripTrailingSlash).path();
76​ return (path.isEmpty() || path == QLatin1String("/"));
77​}
78​
79​
80​RecentlyUsed::RecentlyUsed(const QByteArray& pool, const QByteArray& app):
81​ ForwardingSlaveBase("recentlyused", pool, app)
82​{}
83​
84​RecentlyUsed::~RecentlyUsed()
85​{}
86​
87​
88​bool RecentlyUsed::rewriteUrl(const QUrl& url, QUrl& newUrl)
89​{
90​ Q_UNUSED(url);
91​ Q_UNUSED(newUrl);
92​ return false;
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​
95​ResultModel* runQuery(const QUrl& url) {
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​ if (typeValue.contains(QLatin1Char(','))) {
108​ // multiple mimetypes were passed
109​ query = query | Type(typeValue.split(QLatin1Char(',')));
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​ query = query | Type(typeValue);
112​ }
113​ }
114​
115​ // limit parameter
116​ if (urlQuery.hasQueryItem(QStringLiteral("limit"))) {
117​ auto limitValue = urlQuery.queryItemValue(QStringLiteral("limit"));
118​ bool parseOk;
119​ auto limitInt = limitValue.toInt(&parseOk);
120​ if (parseOk) {
121​ query = query | Limit(limitInt);
122​ }
123​ }
124​
125​ // acitivity parameter, filter using the uuid of the activity
126​ if (urlQuery.hasQueryItem(QStringLiteral("activity"))) {
127​ auto activityValue = urlQuery.queryItemValue(QStringLiteral("activity"));
128​ if (activityValue == QStringLiteral("any")) {
129​ query = query | Activity::any();
130​ } else {
131​ query = query | Activity(activityValue);
132​ }
133​ } else {
134​ query = query | Activity::current();
135​ }
136​
137​ // agent parameter, filter using the application name that used the resource
138​ if (urlQuery.hasQueryItem(QStringLiteral("agent"))) {
139​ auto agentValue = urlQuery.queryItemValue(QStringLiteral("agent"));
140​ if (agentValue == QStringLiteral("current")) {
141​ query = query | Agent::current();
142​ } else if (agentValue.contains(QLatin1Char(','))) {
143​ query = query | Agent(agentValue.split(QLatin1Char(',')));
144​ } else {
ngrahamUnsubmitted
Done

Missing a space before else if

ngraham: Missing a space before `else if`
145​ query = query | Agent(agentValue);
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​ }
147​ } else {
148​ query = query | Agent::any();
149​ }
150​
151​ // url parameter for exact path match or folders, supports wildcard pattern matching
152​ if (urlQuery.hasQueryItem(QStringLiteral("url"))) {
153​ query = query | Url(urlQuery.queryItemValue(QStringLiteral("url")));
154​ } else {
155​ query = query | Url::file();
156​ }
157​
158​ // see KActivities::Stats::Terms::Order
159​ if (urlQuery.hasQueryItem(QStringLiteral("order"))) {
160​ auto orderValue = urlQuery.queryItemValue(QStringLiteral("order"));
161​
162​ if (orderValue == QStringLiteral("HighScoredFirst")) {
163​ query = query | Order::HighScoredFirst;
164​ } else if (orderValue == QStringLiteral("RecentlyCreatedFirst")) {
165​ query = query | Order::RecentlyCreatedFirst;
166​ } else if (orderValue == QStringLiteral("OrderByUrl")) {
167​ query = query | Order::OrderByUrl;
168​ } else if (orderValue == QStringLiteral("OrderByTitle")) {
169​ query = query | Order::OrderByTitle;
170​ } else {
171​ query = query | Order::RecentlyUsedFirst;
172​ }
173​ } else {
174​ query = query | Order::RecentlyUsedFirst;
175​ }
176​
177​ return new ResultModel(query);
178​}
179​
180​KIO::UDSEntry RecentlyUsed::udsEntryFromResource(const QString& resource){
181​
182​ // the query only returns files and folders
183​ QUrl resourceUrl = QUrl::fromLocalFile(resource);
184​
185​ KIO::UDSEntry uds;
186​ KIO::StatJob* job = KIO::stat(resourceUrl, KIO::HideProgressInfo);
187​
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​ // we do not want to wait for the event loop to delete the job
189​ QScopedPointer<KIO::StatJob> sp(job);
190​ job->setAutoDelete(false);
191​ if (job->exec()) {
192​ uds = job->statResult();
193​ }
194​ uds.fastInsert(KIO::UDSEntry::UDS_URL, resourceUrl.toString());
195​ return uds;
196​}
197​
198​void RecentlyUsed::listDir(const QUrl& url)
199​{
200​ if (!isRootUrl(url)) {
201​ error(KIO::ERR_DOES_NOT_EXIST, url.toDisplayString());
202​ return;
203​ }
204​
205​ auto model = runQuery(url);
206​
207​ KIO::UDSEntryList udslist;
208​ udslist.reserve(model->rowCount());
209​
210​ for (int r = 0; r < model->rowCount(); ++r) {
211​ QModelIndex index = model->index(r, 0);
212​ QString resource = model->data(index, ResultModel::ResourceRole).toString();
ngrahamUnsubmitted
Done

space after for

ngraham: space after `for`
213​
214​ udslist << udsEntryFromResource(resource);
215​ }
216​
217​ listEntries(udslist);
218​ finished();
219​}
220​
221​void RecentlyUsed::stat(const QUrl& url)
222​{
223​ qCDebug(KIO_RECENTLYUSED_LOG) << "stating" << " " << url;
224​
225​ if (isRootUrl(url)) {
226​ //
227​ // stat the root path
228​ //
229​
230​ QString dirName = i18n("Recent Documents");
231​ KIO::UDSEntry uds;
232​ uds.reserve(5);
233​ uds.fastInsert(KIO::UDSEntry::UDS_NAME, dirName);
234​ uds.fastInsert(KIO::UDSEntry::UDS_DISPLAY_NAME, dirName);
235​ uds.fastInsert(KIO::UDSEntry::UDS_DISPLAY_TYPE, dirName);
236​ uds.fastInsert(KIO::UDSEntry::UDS_ICON_NAME, QStringLiteral("document-open-recent"));
237​ uds.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR);
238​ uds.fastInsert(KIO::UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory"));
239​
240​ statEntry(uds);
241​ finished();
242​ } else {
243​ auto model = runQuery(url);
244​ if (model->rowCount() != 1) {
245​ error(KIO::ERR_DOES_NOT_EXIST, url.toDisplayString());
246​ return ;
dfaureUnsubmitted
Done

I count 6...

dfaure: I count 6...
247​ }
248​
249​ QModelIndex index = model->index(0, 0);
250​ QString resource = model->data(index, ResultModel::ResourceRole).toString();
251​ statEntry(udsEntryFromResource(resource));
ivanUnsubmitted
Done

QStringLiteral?

ivan: `QStringLiteral`?
252​
253​ finished();
254​ }
255​}
256​
257​void RecentlyUsed::mimetype(const QUrl& url)
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​{
259​ // the root url is always a folder
260​ if (isRootUrl(url)) {
261​ mimeType(QString::fromLatin1("inode/directory"));
262​ finished();
263​ }
264​ // others urls are forwarded
265​ else {
266​ ForwardingSlaveBase::mimetype(url);
267​ }
268​}
269​
270​// needed for JSON file embedding
271​#include "recentlyused.moc"