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

IJHack / QtPass / 43701036262

15 Nov 2026 09:48AM UTC coverage: 96.249% (-0.03%) from 96.28%
43701036262

push

github

web-flow
Search: Return in the search box only searches (#2180)

QLineEdit emits returnPressed() and leaves the Return key unaccepted, so
after on_lineEdit_returnPressed() had run, the same key reached
MainWindow::keyPressEvent(), which opened the tree's current entry with no
look at the search mode. In content search, Return started the search and
also decrypted and showed that entry, one the user had not asked for:
back in clear after the panel autoclear hid it, copied again with "Always
copy", and after a name search one never opened. Return on an empty box in
content search did the same. In the name search Return decrypted the first
hit twice. Return on a content search result opened the entry hidden
behind the list, not the result.

eventFilter() hands Return and Enter in the search box to the box itself
and then stops them, so returnPressed() runs as before and the window
never sees the key. While the results list hides the tree, keyPressEvent()
opens the focused list's current result, as a click does, and never the
hidden tree's entry.

Tests returnInTheSearchBoxEndsThere (content search, empty box, name
search decrypts once) and returnOnAContentSearchResultOpensIt. Removing
the filter, the hidden-tree branch or the result's opening each fails a
test; stopping Return only in content search fails the "decrypts once"
check (2 decrypts). Finding VIZFX94A.

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

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

3 existing lines in 1 file now uncovered.

8545 of 8878 relevant lines covered (96.25%)

577.93 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,
446 ✔
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);
446 ✔
47
  QString plaintext;
446 ✔
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;
446 ✔
52
  gpg.setProcessEnvironment(env);
446 ✔
53
  const int rc = Executor::executeBlocking(
446 ✔
54
      gpg, gpgExe,
55
      QStringList{"-d", "--quiet", "--yes", "--no-encrypt-to", "--batch",
446 ✔
56
                  "--use-agent"} +
6,244 ✔
57
          Pass::maxOutputArgs() + QStringList{translatedPath},
2,230 ✔
58
      QString(), &plaintext, nullptr, cancel);
446 ✔
59
  if (rc != 0 || plaintext.isEmpty())
446 ✔
60
    return {};
35 ✔
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
}
446 ✔
103

104
/**
105
 * @brief Walk the store, decrypt every .gpg file, collect matches.
106
 */
107
auto NativeGrep::scanStore(const QProcessEnvironment &env,
14 ✔
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;
14 ✔
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");
42 ✔
118
  for (const QString &filePath : files) {
455 ✔
119
    if (QThread::currentThread()->isInterruptionRequested() ||
443 ✔
120
        (cancel != nullptr && cancel->load()))
98 ✔
121
      return {};
×
122
    if (total == kMaxMatches) {
443 ✔
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);
441 ✔
128
    if (matches.isEmpty())
441 ✔
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,
11 ✔
161
                        const QString &gpgExe, const QString &storeDir,
162
                        const QProcessEnvironment &env) {
163
  cancel();
11 ✔
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;
11 ✔
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()) {
11 ✔
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{});
11 ✔
190
  if (!rx.isValid()) {
11 ✔
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) {
20 ✔
203
    if (!self)
10 ✔
204
      return;
205
    QMetaObject::invokeMethod(
10 ✔
206
        self,
207
        [self, seq, results = std::move(results)]() {
30 ✔
208
          if (self && self->m_seq == seq)
20 ✔
209
            emit self->finished(results);
10 ✔
210
        },
10 ✔
211
        Qt::QueuedConnection);
212
  };
10 ✔
213

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

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

230
void NativeGrep::cancel() {
459 ✔
231
  for (const Worker &w : std::as_const(m_workers)) {
461 ✔
232
    w.cancel->store(true);
233
    if (w.thread && w.thread->isRunning())
2 ✔
234
      w.thread->requestInterruption();
1 ✔
235
  }
236
}
459 ✔
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