File indexing completed on 2024-05-19 05:54:09

 /*
     SPDX-FileCopyrightText: 2007-2008 Robert Knight <robertknight@gmail.com>
     SPDX-FileCopyrightText: 2020 Tomaz Canabrava <tcanabrava@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "FileFilter.h"
 
 #include <QDir>
 
 #include "profile/Profile.h"
 #include "session/Session.h"
 #include "session/SessionManager.h"
 
 #include "FileFilterHotspot.h"
 
 using namespace Konsole;
 
 // static
 QRegularExpression FileFilter::_regex;
 
 FileFilter::FileFilter(Session *session, const QString &wordCharacters)
     : _session(session)
     , _dirPath(QString())
     , _currentDirContents()
 {
     _regex = QRegularExpression(concatRegexPattern(wordCharacters), QRegularExpression::DontCaptureOption);
     setRegExp(_regex);
 }
 
 QString FileFilter::concatRegexPattern(QString wordCharacters) const
 {
     /* The wordCharacters can be a potentially broken regexp,
      * so let's fix it manually if it has some troublesome characters.
      */
     // Add a folder delimiter at the beginning.
     if (wordCharacters.contains(QLatin1Char('/'))) {
         wordCharacters.remove(QLatin1Char('/'));
         wordCharacters.prepend(QStringLiteral("\\/"));
     }
 
     // Add minus at the end.
     if (wordCharacters.contains(QLatin1Char('-'))) {
         wordCharacters.remove(QLatin1Char('-'));
         wordCharacters.append(QLatin1Char('-'));
     }
 
     const QString pattern =
         /* First part of the regexp means 'strings with spaces and starting with single quotes'
          * Second part means "Strings with double quotes"
          * Last part means "Everything else plus some special chars
          * This is much smaller, and faster, than the previous regexp
          * on the HotSpot creation we verify if this is indeed a file, so there's
          * no problem on testing on random words on the screen.
          */
         QStringLiteral(R"RX('[^'\n]+')RX") // Matches everything between single quotes.
         + QStringLiteral(R"RX(|"[^\n"]+")RX") // Matches everything inside double quotes
         // Matches a contiguous line of alphanumeric characters plus some special ones
         // defined in the profile. With a special case for strings starting with '/' which
         // denotes a path on Linux.
         // Takes into account line numbers:
         // - grep output with line numbers: "/path/to/file:123"
         // - compiler error output: ":/path/to/file:123:123"
         //
         // ([^\n/\[]/) to not match "https://", and urls starting with "[" are matched by the
         // next | branch (ctest stuff)
         + QStringLiteral(R"RX(|([^\n\s/\[]/)?[\p{L}\w%1]+(:\d+)?(:\d+:)?)RX").arg(wordCharacters)
         // - ctest error output: "[/path/to/file(123)]"
         + QStringLiteral(R"RX(|\[[/\w%1]+\(\d+\)\])RX").arg(wordCharacters);
 
     return pattern;
 }
 
 /**
  * File Filter - Construct a filter that works on local file paths using the
  * posix portable filename character set combined with KDE's mimetype filename
  * extension blob patterns.
  * https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_267
  */
 
 QSharedPointer<HotSpot> FileFilter::newHotSpot(int startLine, int startColumn, int endLine, int endColumn, const QStringList &capturedTexts)
 {
     if (_session.isNull()) {
         return nullptr;
     }
 
     const QString &filenameRef = capturedTexts.first();
     QStringView filename = filenameRef;
     if (filename.startsWith(QLatin1Char('\'')) && filename.endsWith(QLatin1Char('\''))) {
         filename = filename.mid(1, filename.size() - 2);
     }
 
     // '.' and '..' could be valid hotspots, but '..................' most likely isn't
     static const QRegularExpression allDotRe{QRegularExpression::anchoredPattern(QStringLiteral("\\.{3}"))};
     if (allDotRe.match(filename).hasMatch()) {
         return nullptr;
     }
 
     if (filename.startsWith(QLatin1String("[/"))) { // ctest error output
         filename = filename.mid(1);
     }
 
     const bool absolute = filename.startsWith(QLatin1Char('/'));
     if (!absolute) {
         auto match = std::find_if(_currentDirContents.cbegin(), _currentDirContents.cend(), [filename](const QString &s) {
             // early out if first char doesn't match
             if (!s.isEmpty() && filename.at(0) != s.at(0)) {
                 return false;
             }
 
             const bool startsWith = filename.startsWith(s);
             if (startsWith) {
                 // are we equal ?
                 if (filename.size() == s.size()) {
                     return true;
                 }
                 int onePast = s.size();
                 if (onePast < filename.size()) {
                     if (filename.at(onePast) == QLatin1Char(':') || filename.at(onePast) == QLatin1Char('/')) {
                         return true;
                     }
                 }
             }
             return false;
         });
 
         if (match == _currentDirContents.cend()) {
             return nullptr;
         }
     }
 
     return QSharedPointer<HotSpot>(new FileFilterHotSpot(startLine,
                                                          startColumn,
                                                          endLine,
                                                          endColumn,
                                                          capturedTexts,
                                                          !absolute ? _dirPath + filename.toString() : filename.toString(),
                                                          _session));
 }
 
 void FileFilter::process()
 {
     const QDir dir(_session->currentWorkingDirectory());
     // Do not re-process.
     if (_dirPath != dir.canonicalPath() + QLatin1Char('/')) {
         _dirPath = dir.canonicalPath() + QLatin1Char('/');
 
         _currentDirContents = dir.entryList(QDir::Dirs | QDir::Files);
     }
 
     RegExpFilter::process();
 }
 
 void FileFilter::updateRegex(const QString &wordCharacters)
 {
     _regex.setPattern(concatRegexPattern(wordCharacters));
     setRegExp(_regex);
 }