Differential D27166 Diff 78287 runners/converter/converterrunner.cpp

Changeset View

Standalone View

runners/converter/converterrunner.cpp

1	/*	1		/*
2	* Copyright (C) 2007,2008 Petri Damstén <damu@iki.fi>	2		* Copyright (C) 2007,2008 Petri Damstén <damu@iki.fi>
		3		* Copyright (C) 2020 Alexander Lohnau <alexander.lohnau@gmx.de>
3	*	4		*
4	* This program is free software; you can redistribute it and/or	5		* This program is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU General Public License as	6		* modify it under the terms of the GNU General Public License as
6	* published by the Free Software Foundation; either version 2 of	7		* published by the Free Software Foundation; either version 2 of
7	* the License, or (at your option) any later version.	8		* the License, or (at your option) any later version.
8	*	9		*
9	* This program is distributed in the hope that it will be useful,	10		* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.	13		* GNU General Public License for more details.
13	*	14		*
14	* You should have received a copy of the GNU General Public License	15		* You should have received a copy of the GNU General Public License
15	* along with this program. If not, see <http://www.gnu.org/licenses/>.	16		* along with this program. If not, see <http://www.gnu.org/licenses/>.
16	*/	17		*/
17		18
		19
			sitterUnsubmitted Done Please move this after the includes. If any header in the future decides to want to use the name as well we're in for an awkward debugging session. sitter: Please move this after the includes. If any header in the future decides to want to use the…
18	#include "converterrunner.h"	20		#include "converterrunner.h"
		21
19	#include <QGuiApplication>	22		#include <QGuiApplication>
20	#include <QClipboard>	23		#include <QClipboard>
21	#include <QDesktopServices>	24		#include <QDesktopServices>
22	#include <QSet>
23	#include <QDebug>	25		#include <QDebug>
24	#include <KLocalizedString>	26		#include <KLocalizedString>
25	#include <KUnitConversion/Converter>
26	#include <KUnitConversion/UnitCategory>
27		27
28	#include <cmath>	28		#include <cmath>
29		29
30	#define CONVERSION_CHAR QLatin1Char( '>' )
31
32	K_EXPORT_PLASMA_RUNNER(converterrunner, ConverterRunner)	30		K_EXPORT_PLASMA_RUNNER(converterrunner, ConverterRunner)
33		31
34	class StringParser	32		ConverterRunner::ConverterRunner(QObject *parent, const QVariantList &args)
35	{	33		: Plasma::AbstractRunner(parent, args)
36	public:
37	enum GetType
38	{
39	GetString = 1,
40	GetDigit = 2
41	};
42
43	StringParser(const QString &s) : m_index(0), m_s(s) {}
44	~StringParser() {}
45
46	QString get(int type)
47	{	34		{
48	QChar current;	35		setObjectName(QStringLiteral("Converter"));
49	QString result;	36		//can not ignore commands: we have things like m4
		37		setIgnoredTypes(Plasma::RunnerContext::Directory \| Plasma::RunnerContext::File \|
		38		Plasma::RunnerContext::NetworkLocation);
50		39
51	passWhiteSpace();	40		const QString description = i18n("Converts the value of :q: when :q: is made up of "
52	while (true) {	41		"\"value unit [>, to, as, in] unit\". You can use the "
53	current = next();	42		"Unit converter applet to find all available units.");
54	if (current.isNull()) {	43		addSyntax(Plasma::RunnerSyntax(QStringLiteral(":q:"), description));
55	break;
56	}
57	if (current.isSpace()) {
58	break;
59	}
60	bool number = isNumber(current);
61	if (type == GetDigit && !number) {
62	break;
63	}
64	if (type == GetString && number) {
65	break;
66	}
67	if(current == QLatin1Char( CONVERSION_CHAR )) {
68	break;
69	}
70	++m_index;
71	result += current;
72	}
73	return result;
74	}	44		}
75		45
76	bool isNumber(const QChar &ch)	46		void ConverterRunner::init()
77	{	47		{
78	if (ch.isNumber()) {	48		valueRegex = QRegularExpression(QStringLiteral("^([0-9,./+-]+)"));
79	return true;	49		const QStringList conversionWords = i18nc("list of words that can used as amount of 'unit1' [in\|to\|as] 'unit2'",
80	}	50		"in;to;as").split(QLatin1Char(';'));
81	if (QStringLiteral(".,-+/").contains(ch)) {	51		QString conversionRegex;
82	return true;	52		for (const auto &word: conversionWords) {
83	}	53		conversionRegex.append(QLatin1Char(' ') + word + QStringLiteral(" \|"));
84	return false;
85	}	54		}
		55		conversionRegex.append(QStringLiteral(" ?> ?"));
		56		unitSeperatorRegex = QRegularExpression(conversionRegex);
		57		valueRegex.optimize();
		58		unitSeperatorRegex.optimize();
86		59
87	QString rest()	60		insertCompatibleUnits();
88	{	61
89	return m_s.mid(m_index).simplified();	62		addAction(copyActionId, QIcon::fromTheme(QStringLiteral("edit-copy")),
		63		QStringLiteral("Copy number"));
		64		addAction(copyUnitActionId, QIcon::fromTheme(QStringLiteral("edit-copy")),
		65		QStringLiteral("Copy unit and number"));
		66		actionList = {action(copyActionId), action(copyUnitActionId)};
90	}	67		}
91		68
92	void pass(const QStringList &strings)	69		ConverterRunner::~ConverterRunner() = default;
93	{
94	passWhiteSpace();
95	const QString temp = m_s.mid(m_index);
96		70
97	foreach (const QString& s, strings) {	71		void ConverterRunner::match(Plasma::RunnerContext &context)
98	if (temp.startsWith(s)) {	72		{
99	m_index += s.length();	73		const QString term = context.query();
		74		if (term.size() < 2 \|\| !context.isValid()) {
100	return;	75		return;
101	}	76		}
		77
		78		const QRegularExpressionMatch valueRegexMatch = valueRegex.match(context.query());
		79		if (!valueRegexMatch.hasMatch()) {
		80		return;
102	}	81		}
103	}	82		const QString inputValueString = valueRegexMatch.captured(1);
104		83
105	private:	84		// Get the different units by splitting up the query with the regex
106	void passWhiteSpace()	85		QStringList unitStrings = context.query().simplified().remove(valueRegex).split(unitSeperatorRegex);
107	{	86		if (unitStrings.isEmpty()) {
108	while (next().isSpace()) {	87		return;
109	++m_index;
110	}	88		}
		89		// Check if unit is valid, otherwise check for the value in the compatibleUnits map
		90		QString inputUnitString = unitStrings.first().simplified();
		91		KUnitConversion::UnitCategory inputCategory = converter.categoryForUnit(inputUnitString);
		92		if (inputCategory.id() == KUnitConversion::InvalidCategory) {
		93		inputUnitString = compatibleUnits.value(inputUnitString.toUpper());
		94		if (inputUnitString.isEmpty()) {
		95		return;
111	}	96		}
112		97		inputCategory = converter.categoryForUnit(inputUnitString);
113	QChar next()	98		if (inputCategory.id() == KUnitConversion::InvalidCategory) {
114	{	99		return;
115	if (m_index >= m_s.size()) {
116	return QChar::Null;
117	}	100		}
118	return m_s.at(m_index);
119	}	101		}
120		102
121	int m_index;	103		QString outputUnitString;
122	QString m_s;	104		if (unitStrings.size() == 2) {
123	};	105		outputUnitString = unitStrings.at(1).simplified();
			broulikUnsubmitted Done There's also units with µ, Ω, . (fl.oz.), not taking into account how those might be localized, so using a very specific regexp looks somewhat brittle to me. Can't really think of a better way, though... broulik: There's also units with µ, Ω, . (fl.oz.), not taking into account how those might be localized…
			alexAuthorUnsubmitted Done Well the only idea I have is to allow everything as a unit and let the conversion backend decide if it is valid. alex: Well the only idea I have is to allow everything as a unit and let the conversion backend…
		106		}
124		107
125	ConverterRunner::ConverterRunner(QObject* parent, const QVariantList &args)	108		const KUnitConversion::Unit inputUnit = inputCategory.unit(inputUnitString);
126	: Plasma::AbstractRunner(parent, args)	109		const QList<KUnitConversion::Unit> outputUnits = createResultUnits(outputUnitString, inputCategory);
127	{	110		const auto numberDataPair = getValidatedNumberValue(inputValueString);
128	Q_UNUSED(args)	111		// Return on invalid user input
129	setObjectName(QLatin1String( "Converter" ));	112		if (!numberDataPair.first) {
		113		return;
		114		}
130		115
131	m_separators << QString( CONVERSION_CHAR );	116		const double numberValue = numberDataPair.second;
132	m_separators << i18nc("list of words that can used as amount of 'unit1' [in\|to\|as] 'unit2'",	117		QList<Plasma::QueryMatch> matches;
133	"in;to;as").split(QLatin1Char( ';' ));	118		for (const KUnitConversion::Unit &outputUnit: outputUnits) {
		119		KUnitConversion::Value outputValue = inputCategory.convert(
		120		KUnitConversion::Value(numberValue, inputUnit), outputUnit);
		121		if (!outputValue.isValid() \|\| inputUnit == outputUnit) {
		122		continue;
		123		}
134		124
135	//can not ignore commands: we have things like m4	125		Plasma::QueryMatch match(this);
136	setIgnoredTypes(Plasma::RunnerContext::Directory \| Plasma::RunnerContext::File \|	126		match.setType(Plasma::QueryMatch::InformationalMatch);
			broulikUnsubmitted Done When there's just one decimal, it doesn't add a zero broulik: When there's just one decimal, it doesn't add a zero
137	Plasma::RunnerContext::NetworkLocation);	127		match.setIconName(QStringLiteral("accessories-calculator"));
		128		if (outputUnit.categoryId() == KUnitConversion::CurrencyCategory) {
		129		outputValue.round(2);
		130		match.setText(QStringLiteral("%1 (%2)").arg(outputValue.toString(0, 'f', 2), outputUnit.symbol()));
		131		} else {
		132		match.setText(QStringLiteral("%1 (%2)").arg(outputValue.toString(), outputUnit.symbol()));
		133		}
		134		match.setData(outputValue.number());
			broulikUnsubmitted Done I thought `KUnitConversion` was doing that when requesting a pretty string broulik: I thought `KUnitConversion` was doing that when requesting a pretty string
		135		match.setRelevance(1.0 - std::abs(std::log10(outputValue.number())) / 50.0);
		136		matches.append(match);
		137		}
138		138
139	QString description = i18n("Converts the value of :q: when :q: is made up of "	139		context.addMatches(matches);
140	"\"value unit [>, to, as, in] unit\". You can use the "
141	"Unit converter applet to find all available units.");
142	addSyntax(Plasma::RunnerSyntax(QLatin1String(":q:"), description));
143	}	140		}
144		141
145	ConverterRunner::~ConverterRunner()	142		QList<QAction *> ConverterRunner::actionsForMatch(const Plasma::QueryMatch &match)
146	{	143		{
		144		Q_UNUSED(match)
		145
		146		return actionList;
147	}	147		}
148		148
149	void ConverterRunner::match(Plasma::RunnerContext &context)	149		void ConverterRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match)
150	{	150		{
151	const QString term = context.query();	151		Q_UNUSED(context)
152	if (term.size() < 2) {
153	return;
154	}
155		152
156	StringParser cmd(term);	153		if (match.selectedAction() == action(copyActionId)) {
157	QString unit1;	154		QGuiApplication::clipboard()->setText(match.data().toString());
158	QString value;	155		} else {
159	QString unit2;	156		QGuiApplication::clipboard()->setText(match.text().split(QLatin1String(" (")).first());
160
161	unit1 = cmd.get(StringParser::GetString);
162	value = cmd.get(StringParser::GetDigit);
163	if (value.isEmpty()) {
164	return;
165	}
166	if (unit1.isEmpty()) {
167	unit1 = cmd.get(StringParser::GetString \| StringParser::GetDigit);
168	if (unit1.isEmpty()) {
169	return;
170	}	157		}
171	}	158		}
172		159
173	const QString s = cmd.get(StringParser::GetString);	160		QPair<bool, double> ConverterRunner::stringToDouble(const QStringRef &value)
			sitterUnsubmitted Done Seeing as this now doesn't do anything you can `= default` it. sitter: Seeing as this now doesn't do anything you can `= default` it.
174		161		{
			sitterUnsubmitted Done I am sure we can do better than hardcoding currency symbols. Perhaps iterate QLocales and get the currencySymbol for each? (needs checking that performance doesn't degrade) sitter: I am sure we can do better than hardcoding currency symbols. Perhaps iterate QLocales and get…
175	if (!s.isEmpty() && !m_separators.contains(s)) {	162		bool ok;
176	unit1 += QLatin1Char( ' ' ) + s;	163		double numberValue = locale.toDouble(value, &ok);
			sitterUnsubmitted Done I'd really prefer named capture groups. Popping data out of the captures by index is fairly terrible to read and also easier to mess up in the future. sitter: I'd really prefer named capture groups. Popping data out of the captures by index is fairly…
		164		if (!ok) {
		165		numberValue = value.toDouble(&ok);
177	}	166		}
178	if (s.isEmpty() \|\| !m_separators.contains(s)) {	167		return {ok, numberValue};
179	cmd.pass(m_separators);
180	}	168		}
181	unit2 = cmd.rest();
182		169
183	KUnitConversion::Converter converter;	170		QPair<bool, double> ConverterRunner::getValidatedNumberValue(const QString &value)
184	KUnitConversion::UnitCategory category = converter.categoryForUnit(unit1);	171		{
185	bool found = false;	172		#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
			sitterUnsubmitted Done Is there a particular reason you hold it as a reference? (also applies to a bunch of QStrings and QLists below). We generally do not hold Qt types as references unless there is a reason to I think. sitter: Is there a particular reason you hold it as a reference? (also applies to a bunch of QStrings…
			sitterUnsubmitted Done unnecessary ref. sitter: unnecessary ref.
186	if (category.id() == KUnitConversion::InvalidCategory) {	173		const auto fractionParts = value.splitRef(QLatin1Char('/'), QString::SkipEmptyParts);
187	foreach (category, converter.categories()) {	174		#else
188	foreach (const QString& s, category.allUnits()) {	175		const auto fractionParts = value.splitRef(QLatin1Char('/'), Qt::SkipEmptyParts);
189	if (s.compare(unit1, Qt::CaseInsensitive) == 0) {	176		#endif
190	unit1 = s;	177		if (fractionParts.isEmpty() \|\| fractionParts.count() > 2) {
191	found = true;	178		return {false, 0};
192	break;
193	}
194	}	179		}
195	if (found) {	180
196	break;	181		if (fractionParts.count() == 2) {
			sitterUnsubmitted Done Please use more descriptive names than u1, such as unit1. In fact, isn't unit1 "inputUnit" and unit2 "outputUnit"? If so I'd name them thusly. sitter: Please use more descriptive names than u1, such as unit1. In fact, isn't unit1 "inputUnit" and…
		182		const QPair<bool, double> doubleFirstResults = stringToDouble(fractionParts.first());
			sitterUnsubmitted Done unnecessary ref. sitter: unnecessary ref.
		183		if (!doubleFirstResults.first) {
		184		return {false, 0};
			sitterUnsubmitted Done `s/u/unit` sitter: `s/u/unit`
		185		}
			sitterUnsubmitted Done unit1 and unit2 should probably be unitString1 and unitString2 so the actual units can be unit1 and unit2. same for value I suppose. sitter: unit1 and unit2 should probably be unitString1 and unitString2 so the actual units can be unit1…
			sitterUnsubmitted Done `s/v/value` sitter: `s/v/value`
		186		const QPair<bool, double> doubleSecondResult = stringToDouble(fractionParts.last());
		187		if (!doubleSecondResult.first \|\| qFuzzyIsNull(doubleSecondResult.second)) {
		188		return {false, 0};
			sitterUnsubmitted Done in all return statements you can use list initialization `return { ok, output };` sitter: in all return statements you can use list initialization `return { ok, output };`
197	}	189		}
			sitterUnsubmitted Done newline missing it seems sitter: newline missing it seems
		190		return {true, doubleFirstResults.second / doubleSecondResult.second};
		191		} else if (fractionParts.count() == 1) {
		192		const QPair<bool, double> doubleResult = stringToDouble(fractionParts.first());
		193		if (!doubleResult.first) {
		194		return {false, 0};
198	}	195		}
			sitterUnsubmitted Done left over debug sitter: left over debug
199	if (!found) {	196		return {true, doubleResult.second};
200	return;	197		} else {
		198		return {true, 0};
201	}	199		}
202	}	200		}
203		201
		202		QList<KUnitConversion::Unit> ConverterRunner::createResultUnits(QString &outputUnitString,
		203		const KUnitConversion::UnitCategory &category)
		204		{
204	QList<KUnitConversion::Unit> units;	205		QList<KUnitConversion::Unit> units;
205		206		if (!outputUnitString.isEmpty()) {
206	if (!unit2.isEmpty()) {	207		KUnitConversion::Unit outputUnit = category.unit(outputUnitString);
207	KUnitConversion::Unit u = category.unit(unit2);	208		if (!outputUnit.isNull() && outputUnit.isValid()) {
208	if (!u.isNull() && u.isValid()) {	209		units.append(outputUnit);
209	units.append(u);
210	config().writeEntry(category.name(), u.symbol());
211	} else {	210		} else {
212	const QStringList unitStrings = category.allUnits();	211		// Autocompletion for the target units
213	QList<KUnitConversion::Unit> matchingUnits;	212		outputUnitString = outputUnitString.toUpper();
214	foreach (const QString& s, unitStrings) {	213		for (const auto &unitStringKey: compatibleUnits.keys()) {
215	if (s.startsWith(unit2, Qt::CaseInsensitive)) {	214		if (unitStringKey.startsWith(outputUnitString)) {
216	u = category.unit(s);	215		outputUnit = category.unit(compatibleUnits.value(unitStringKey));
217	if (!matchingUnits.contains(u)) {	216		if (!units.contains(outputUnit)) {
218	matchingUnits << u;	217		units << outputUnit;
219	}
220	}	218		}
221	}	219		}
222	units = matchingUnits;
223	if (units.count() == 1) {
224	config().writeEntry(category.name(), units[0].symbol());
225	}	220		}
226	}	221		}
227	} else {	222		} else {
228	units = category.mostCommonUnits();	223		units = category.mostCommonUnits();
229	KUnitConversion::Unit u = category.unit(config().readEntry(category.name()));
230	if (!u.isNull() && units.indexOf(u) < 0) {
231	units << u;
232	}
233
234	// suggest converting to the user's local currency	224		// suggest converting to the user's local currency
235	if (category.id() == KUnitConversion::CurrencyCategory) {	225		if (category.id() == KUnitConversion::CurrencyCategory) {
236	const QString &currencyIsoCode = QLocale().currencySymbol(QLocale::CurrencyIsoCode);	226		const QString &currencyIsoCode = QLocale().currencySymbol(QLocale::CurrencyIsoCode);
237		227
238	KUnitConversion::Unit localCurrency = category.unit(currencyIsoCode);	228		const KUnitConversion::Unit localCurrency = category.unit(currencyIsoCode);
239	if (localCurrency.isValid() && !units.contains(localCurrency)) {	229		if (localCurrency.isValid() && !units.contains(localCurrency)) {
240	units << localCurrency;	230		units << localCurrency;
241	}	231		}
242	}	232		}
243	}	233		}
244		234
245	QList<Plasma::QueryMatch> matches;	235		return units;
246
247	QLocale locale;
248	auto stringToDouble = [&locale](const QStringRef &value, bool *ok) {
249	double numberValue = locale.toDouble(value, ok);
250	if (!(*ok)) {
251	numberValue = value.toDouble(ok);
252	}
253	return numberValue;
254	};
255
256	KUnitConversion::Unit u1 = category.unit(unit1);
257	foreach (const KUnitConversion::Unit& u, units) {
258	if (u1 == u) {
259	continue;
260	}
261
262	double numberValue = 0.0;
263
264	#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
265	const auto fractionParts = value.splitRef(QLatin1Char('/'), QString::SkipEmptyParts);
266	#else
267	const auto fractionParts = value.splitRef(QLatin1Char('/'), Qt::SkipEmptyParts);
268	#endif
269	if (fractionParts.isEmpty() \|\| fractionParts.count() > 2) {
270	continue;
271	}
272
273	if (fractionParts.count() == 2) {
274	bool ok;
275	const double numerator = stringToDouble(fractionParts.first(), &ok);
276	if (!ok) {
277	continue;
278	}
279	const double denominator = stringToDouble(fractionParts.last(), &ok);
280	if (!ok \|\| qFuzzyIsNull(denominator)) {
281	continue;
282	}	236		}
		237		void ConverterRunner::insertCompatibleUnits()
		238		{
		239		// Add all currency symbols to the map, if their ISO code is supported by backend
		240		const QList<QLocale> allLocales = QLocale::matchingLocales(
		241		QLocale::AnyLanguage, QLocale::AnyScript, QLocale::AnyCountry);
		242		KUnitConversion::UnitCategory currencyCategory = converter.category(QStringLiteral("Currency"));
		243		const QStringList availableISOCodes = currencyCategory.allUnits();
		244		QRegularExpression hasCurrencyRegex = QRegularExpression(QStringLiteral("\\p{Sc}"));
		245		hasCurrencyRegex.optimize();
		246		for (const auto &currencyLocale: allLocales) {
		247		const QString symbol = currencyLocale.currencySymbol(QLocale::CurrencySymbol);
		248		const QString isoCode = currencyLocale.currencySymbol(QLocale::CurrencyIsoCode);
283		249
284	numberValue = numerator / denominator;	250		if (isoCode.isEmpty() \|\| !symbol.contains(hasCurrencyRegex)) {
285	} else if (fractionParts.count() == 1) {
286	bool ok;
287	numberValue = stringToDouble(fractionParts.first(), &ok);
288	if (!ok) {
289	continue;	251		continue;
290	}	252		}
		253		if (availableISOCodes.contains(isoCode)) {
		254		compatibleUnits.insert(symbol.toUpper(), isoCode);
291	}	255		}
292
293	KUnitConversion::Value v = category.convert(KUnitConversion::Value(numberValue, u1), u);
294
295	if (!v.isValid()) {
296	continue;
297	}
298
299	Plasma::QueryMatch match(this);
300	match.setType(Plasma::QueryMatch::InformationalMatch);
301	match.setIconName(QStringLiteral("edit-copy"));
302	match.setText(QStringLiteral("%1 (%2)").arg(v.toString(), u.symbol()));
303	match.setData(v.number());
304	match.setRelevance(1.0 - std::abs(std::log10(v.number())) / 50.0);
305	matches.append(match);
306	}	256		}
307		257
308	context.addMatches(matches);	258		// Add all units as uppercase in the map
		259		for (const auto &category: converter.categories()) {
		260		for (const auto &unit: category.allUnits()) {
		261		compatibleUnits.insert(unit.toUpper(), unit);
309	}	262		}
310
311	void ConverterRunner::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match)
312	{
313	Q_UNUSED(context)
314	const QString data = match.data().toString();
315	if (data.startsWith(QLatin1String("http://"))) {
316	QDesktopServices::openUrl(QUrl(data));
317	} else {
318	QGuiApplication::clipboard()->setText(data);
319	}	263		}
320	}	264		}
321		265
322	#include "converterrunner.moc"	266		#include "converterrunner.moc"