• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

IJHack / QtPass / 43629066731

14 Nov 2026 06:53PM UTC coverage: 96.26% (-0.04%) from 96.295%
43629066731

push

github

web-flow
Translations: full review of the machine fills, every empty entry translated, consistent address forms (#2169)

* Say "store ID line" in the signed-list messages, for translators

"The store line is malformed" and its siblings name the line of a signed
recipient list that carries the password store's ID. On its own, "store
line" read as a shop, a shelf or a warehouse: a back-translation review of
the machine-filled translations found "shelf line", "tank line", "storage
tax" and "save button" for it in about 20 languages. The four messages now
say "store ID line", which also ties in with the store's "ID %2" in the
longest one, and each carries a translator comment that the store is the
password store.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Anne Jan Brouwer <brouwer@annejan.com>

* chore: update localization source references

make lupdate for the reworded store ID line messages and the four strings
#2163 added (hidden names, places behind a link).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Anne Jan Brouwer <brouwer@annejan.com>

* l10n: fill the new strings, and fix the machine translations a review found

The eight new strings (the store ID line messages, the hidden-name and
behind-a-link refusals) filled with translategemma:4b; nl, de, fr, sr_RS,
sr_Cyrl and sw written by Claude, and the eleven entries the model could
not keep its placeholders in as well.

A back-translation review (qwen3.5:9b) of the 1,180 strings #2133 filled,
and sweeps for the mistakes it showed, found:

- "Store" taken for a shop (tienda, butik, loja, магазин, 商店...): the
  machine-filled entries are emptied, 95 of them, for Weblate; the new
  store ID line messages too, as the model did not follow their
  translator comment. Fifteen finished translations with the same word
  are left for Weblate's reviewers.
- The eye-button help quoting "Hide content" under another name (ca, fr,
  ro, ta; "Ocul" in French): now each... (continued)

3 of 3 new or added lines in 1 file covered. (100.0%)

3 existing lines in 1 file now uncovered.

8443 of 8771 relevant lines covered (96.26%)

469.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.37
/src/nativegrep.cpp
1
// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
2
// SPDX-License-Identifier: GPL-3.0-or-later
3
/**
4
 * @file
5
 * @brief Implements NativeGrep: the store walk, the per-file gpg runs and the
6
 * hand-over of results from the worker thread.
7
 */
8
#include "nativegrep.h"
9
#include "executor.h"
10
#include "pass.h"
11
#include "util.h"
12
#include <QDir>
13
#include <QElapsedTimer>
14
#include <QPointer>
15
#include <QProcess>
16
#include <QRegularExpression>
17
#include <QStringTokenizer>
18
#include <QThread>
19
#include <utility>
20

21
NativeGrep::NativeGrep(QObject *parent) : QObject(parent) {}
224 ✔
22

23
NativeGrep::~NativeGrep() {
224 ✔
24
  static constexpr int kThreadTimeoutMs = 5000;
25
  cancel();
224 ✔
26
  QElapsedTimer elapsed;
224 ✔
27
  elapsed.start();
224 ✔
28
  for (const Worker &w : std::as_const(m_workers)) {
225 ✔
29
    if (w.thread && w.thread->isRunning()) {
1 ✔
30
      const int remaining =
UNCOV
31
          kThreadTimeoutMs - static_cast<int>(elapsed.elapsed());
×
UNCOV
32
      if (remaining > 0)
×
UNCOV
33
        w.thread->wait(remaining);
×
34
    }
35
  }
36
}
224 ✔
37

38
/**
39
 * @brief Decrypt one .gpg file and return lines matching rx.
40
 */
41
auto NativeGrep::matchFile(const QProcessEnvironment &env,
415 ✔
42
                           const QString &gpgExe, const QString &filePath,
43
                           const QRegularExpression &rx,
44
                           const std::atomic_bool *cancel) -> QStringList {
45
  const QString translatedPath =
46
      Executor::translatePathForWsl(filePath, gpgExe);
415 ✔
47
  QString plaintext;
415 ✔
48
  // The QProcess overload is the one that takes the cancel flag; it polls
49
  // the flag while waiting and terminates (then kills) gpg from this thread,
50
  // the one that owns the process.
51
  QProcess gpg;
415 ✔
52
  gpg.setProcessEnvironment(env);
415 ✔
53
  const int rc = Executor::executeBlocking(
415 ✔
54
      gpg, gpgExe,
55
      QStringList{"-d", "--quiet", "--yes", "--no-encrypt-to", "--batch",
415 ✔
56
                  "--use-agent"} +
5,810 ✔
57
          Pass::maxOutputArgs() + QStringList{translatedPath},
2,075 ✔
58
      QString(), &plaintext, nullptr, cancel);
415 ✔
59
  if (rc != 0 || plaintext.isEmpty())
415 ✔
60
    return {};
4 ✔
61
  // Line by line over the text, never a list of every line (a compressed
62
  // entry can expand into tens of millions), and a bounded number taken.
63
  QStringList matches;
411 ✔
64
  for (QStringView line : QStringView(plaintext).tokenize(u'\n')) {
60,957 ✔
65
    if (line.endsWith(u'\r'))
66
      line.chop(1);
67
    const QStringView t = line.trimmed();
68
    if (t.isEmpty())
60,647 ✔
69
      continue;
60,543 ✔
70
    const QRegularExpressionMatch m = rx.matchView(line);
30,284 ✔
71
    if (!m.hasMatch())
30,284 ✔
72
      continue;
6 ✔
73
    if (matches.size() == kMaxMatchesPerEntry) {
30,278 ✔
74
      matches << QString(); // isMoreMarker(): not a match, not counted
101 ✔
75
      break;
76
    }
77
    if (t.size() <= kMaxPreviewLength) {
30,177 ✔
78
      matches << t.toString();
30,174 ✔
79
      continue;
30,174 ✔
80
    }
81
    // A window of the line that holds the match, a little context before
82
    // it; "…" marks what was left out on either side.
83
    const qsizetype at =
84
        qMax<qsizetype>(0, m.capturedStart() - (t.data() - line.data()));
3 ✔
85
    qsizetype start = qBound<qsizetype>(0, at - kMaxPreviewLength / 4,
3 ✔
86
                                        t.size() - kMaxPreviewLength);
3 ✔
87
    qsizetype end = start + kMaxPreviewLength;
3 ✔
88
    // Never half a surrogate pair (an emoji, CJK Extension B) at either
89
    // edge: the window takes the whole character.
90
    if (start > 0 && t[start].isLowSurrogate())
3 ✔
91
      --start;
1 ✔
92
    if (end < t.size() && t[end - 1].isHighSurrogate())
3 ✔
93
      ++end;
1 ✔
94
    QString preview = t.sliced(start, end - start).toString();
3 ✔
95
    if (start > 0)
3 ✔
96
      preview.prepend(QChar(0x2026));
2 ✔
97
    if (end < t.size())
3 ✔
98
      preview.append(QChar(0x2026));
3 ✔
99
    matches << preview;
100
  }
30,284 ✔
101
  return matches;
102
}
415 ✔
103

104
/**
105
 * @brief Walk the store, decrypt every .gpg file, collect matches.
106
 */
107
auto NativeGrep::scanStore(const QProcessEnvironment &env,
13 ✔
108
                           const QString &gpgExe, const QString &storeDir,
109
                           const QRegularExpression &rx,
110
                           const std::atomic_bool *cancel)
111
    -> QList<QPair<QString, QStringList>> {
112
  QList<QPair<QString, QStringList>> results;
13 ✔
113
  int total = 0; // matching lines, the markers not counted
114
  // Regular files only: a link or junction is not an entry, and searching
115
  // through one would decrypt files outside the store.
116
  const QStringList files =
117
      Util::regularFilesUnder(storeDir, QStringList() << "*.gpg");
39 ✔
118
  for (const QString &filePath : files) {
423 ✔
119
    if (QThread::currentThread()->isInterruptionRequested() ||
412 ✔
120
        (cancel != nullptr && cancel->load()))
67 ✔
121
      return {};
×
122
    if (total == kMaxMatches) {
412 ✔
123
      // The budget is spent and entries remain: the search stopped here.
124
      results.append({QString(), {}});
4 ✔
125
      break;
2 ✔
126
    }
127
    QStringList matches = matchFile(env, gpgExe, filePath, rx, cancel);
410 ✔
128
    if (matches.isEmpty())
410 ✔
129
      continue;
130
    const bool more = isMoreMarker(matches.constLast());
131
    if (more)
407 ✔
132
      matches.removeLast();
100 ✔
133
    // The store-wide budget: what still fits, and a marker when that cut
134
    // the entry short.
135
    const int room = kMaxMatches - total;
407 ✔
136
    if (matches.size() > room) {
407 ✔
137
      matches = matches.mid(0, room);
1 ✔
138
      matches << QString();
2 ✔
139
    } else if (more) {
406 ✔
140
      matches << QString();
200 ✔
141
    }
142
    total += static_cast<int>(matches.size()) -
407 ✔
143
             (isMoreMarker(matches.constLast()) ? 1 : 0);
407 ✔
144
    QString entry = QDir(storeDir).relativeFilePath(filePath);
407 ✔
145
    if (entry.endsWith(QLatin1String(".gpg")))
407 ✔
146
      entry.chop(4);
407 ✔
147
    results.append({entry, matches});
407 ✔
148
  }
149
  return results;
150
}
151

152
/**
153
 * @brief Start a search on a worker thread.
154
 *
155
 * Results are emitted on the owner's thread via QMetaObject::invokeMethod. A
156
 * sequence counter discards results from superseded searches; the previous
157
 * search is asked to stop but not waited for, since blocking the UI thread
158
 * while gpg decrypts would freeze the interface.
159
 */
160
void NativeGrep::search(const QString &pattern, bool caseInsensitive,
10 ✔
161
                        const QString &gpgExe, const QString &storeDir,
162
                        const QProcessEnvironment &env) {
163
  cancel();
10 ✔
164

165
  // Advance the sequence before any early return so in-flight workers from the
166
  // previous query fail the seq check and cannot publish stale results.
167
  const int seq = ++m_seq;
10 ✔
168

169
  // Use trimmed() rather than isEmpty(): a whitespace-only string is a valid
170
  // regex that matches every non-empty line, which is almost never intentional
171
  // and would decrypt the entire store.
172
  //
173
  // Both early returns post finished() via Qt::QueuedConnection so that the
174
  // signal is always delivered asynchronously after search() returns, matching
175
  // the contract of the threaded path.
176
  if (pattern.trimmed().isEmpty()) {
10 ✔
177
    QMetaObject::invokeMethod(
×
178
        this,
179
        [this, seq]() {
×
180
          if (m_seq == seq)
×
181
            emit finished({});
×
182
        },
×
183
        Qt::QueuedConnection);
184
    return;
1 ✔
185
  }
186

187
  const QRegularExpression rx(
188
      pattern, caseInsensitive ? QRegularExpression::CaseInsensitiveOption
189
                               : QRegularExpression::PatternOptions{});
10 ✔
190
  if (!rx.isValid()) {
10 ✔
191
    QMetaObject::invokeMethod(
1 ✔
192
        this,
193
        [this, seq]() {
1 ✔
194
          if (m_seq == seq)
1 ✔
195
            emit finished({});
2 ✔
196
        },
1 ✔
197
        Qt::QueuedConnection);
198
    return;
199
  }
200
  QPointer<NativeGrep> self(this);
201

202
  auto emitResults = [self, seq](QList<QPair<QString, QStringList>> results) {
18 ✔
203
    if (!self)
9 ✔
204
      return;
205
    QMetaObject::invokeMethod(
9 ✔
206
        self,
207
        [self, seq, results = std::move(results)]() {
27 ✔
208
          if (self && self->m_seq == seq)
18 ✔
209
            emit self->finished(results);
9 ✔
210
        },
9 ✔
211
        Qt::QueuedConnection);
212
  };
9 ✔
213

214
  auto cancelFlag = std::make_shared<std::atomic_bool>(false);
9 ✔
215
  QThread *thread = QThread::create([gpgExe, storeDir, env, rx, cancelFlag,
18 ✔
216
                                     emitResults = std::move(emitResults)]() {
217
    std::move(emitResults)(
9 ✔
218
        scanStore(env, gpgExe, storeDir, rx, cancelFlag.get()));
9 ✔
219
  });
9 ✔
220

221
  m_workers.append({thread, cancelFlag});
18 ✔
222
  connect(thread, &QThread::finished, thread, &QObject::deleteLater);
9 ✔
223
  connect(thread, &QThread::finished, this, [this, thread]() {
9 ✔
224
    m_workers.removeIf(
8 ✔
225
        [thread](const Worker &w) { return w.thread == thread; });
8 ✔
226
  });
227
  thread->start();
9 ✔
228
}
19 ✔
229

230
void NativeGrep::cancel() {
458 ✔
231
  for (const Worker &w : std::as_const(m_workers)) {
460 ✔
232
    w.cancel->store(true);
233
    if (w.thread && w.thread->isRunning())
2 ✔
234
      w.thread->requestInterruption();
1 ✔
235
  }
236
}
458 ✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc