src/base/path.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2022  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2012  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "path.h"
  31
  32 #include <algorithm>
  33
  34 #include <QDataStream>
  35 #include <QDir>
  36 #include <QFileInfo>
  37 #include <QList>
  38 #include <QMimeDatabase>
  39 #include <QRegularExpression>
  40 #include <QStringView>
  41
  42 #include "base/concepts/stringable.h"
  43 #include "base/global.h"
  44
  45 #if defined(Q_OS_WIN)
  46 const Qt::CaseSensitivity CASE_SENSITIVITY = Qt::CaseInsensitive;
  47 #else
  48 const Qt::CaseSensitivity CASE_SENSITIVITY = Qt::CaseSensitive;
  49 #endif
  50
  51 const int PATHLIST_TYPEID = qRegisterMetaType<PathList>("PathList");
  52
  53 namespace
  54 {
  55     QString cleanPath(const QString &path)
  56     {
  57         const bool hasSeparator = std::any_of(path.cbegin(), path.cend(), [](const QChar c)
  58         {
  59             return (c == u'/') || (c == u'\\');
  60         });
  61         return hasSeparator ? QDir::cleanPath(path) : path;
  62     }
  63
  64 #ifdef Q_OS_WIN
  65     bool hasDriveLetter(const QStringView path)
  66     {
  67         const QRegularExpression driveLetterRegex {u"^[A-Za-z]:/"_s};
  68         return driveLetterRegex.match(path).hasMatch();
  69     }
  70 #endif
  71 }
  72
  73 // `Path` should satisfy `Stringable` concept in order to be stored in settings as string
  74 static_assert(Stringable<Path>);
  75
  76 Path::Path(const QString &pathStr)
  77     : m_pathStr {cleanPath(pathStr)}
  78 {
  79 }
  80
  81 Path::Path(const std::string &pathStr)
  82     : Path(QString::fromStdString(pathStr))
  83 {
  84 }
  85
  86 bool Path::isValid() const
  87 {
  88     // does not support UNC path
  89
  90     if (isEmpty())
  91         return false;
  92
  93     // https://stackoverflow.com/a/31976060
  94 #if defined(Q_OS_WIN)
  95     QStringView view = m_pathStr;
  96     if (hasDriveLetter(view))
  97         view = view.mid(3);
  98
  99     // \\37 is using base-8 number system
 100     const QRegularExpression regex {u"[\\0-\\37:?\"*<>|]"_s};
 101     return !regex.match(view).hasMatch();
 102 #elif defined(Q_OS_MACOS)
 103     const QRegularExpression regex {u"[\\0:]"_s};
 104 #else
 105     const QRegularExpression regex {u"\\0"_s};
 106 #endif
 107     return !m_pathStr.contains(regex);
 108 }
 109
 110 bool Path::isEmpty() const
 111 {
 112     return m_pathStr.isEmpty();
 113 }
 114
 115 bool Path::isAbsolute() const
 116 {
 117     // `QDir::isAbsolutePath` treats `:` as a path to QResource, so handle it manually
 118     if (m_pathStr.startsWith(u':'))
 119         return false;
 120     return QDir::isAbsolutePath(m_pathStr);
 121 }
 122
 123 bool Path::isRelative() const
 124 {
 125     // `QDir::isRelativePath` treats `:` as a path to QResource, so handle it manually
 126     if (m_pathStr.startsWith(u':'))
 127         return true;
 128     return QDir::isRelativePath(m_pathStr);
 129 }
 130
 131 bool Path::exists() const
 132 {
 133     return !isEmpty() && QFileInfo::exists(m_pathStr);
 134 }
 135
 136 Path Path::rootItem() const
 137 {
 138     // does not support UNC path
 139
 140     const int slashIndex = m_pathStr.indexOf(u'/');
 141     if (slashIndex < 0)
 142         return *this;
 143
 144     if (slashIndex == 0) // *nix absolute path
 145         return createUnchecked(u"/"_s);
 146
 147 #ifdef Q_OS_WIN
 148     // should be `c:/` instead of `c:`
 149     if ((slashIndex == 2) && hasDriveLetter(m_pathStr))
 150         return createUnchecked(m_pathStr.left(slashIndex + 1));
 151 #endif
 152     return createUnchecked(m_pathStr.left(slashIndex));
 153 }
 154
 155 Path Path::parentPath() const
 156 {
 157     // does not support UNC path
 158
 159     const int slashIndex = m_pathStr.lastIndexOf(u'/');
 160     if (slashIndex == -1)
 161         return {};
 162
 163     if (slashIndex == 0) // *nix absolute path
 164         return (m_pathStr.size() == 1) ? Path() : createUnchecked(u"/"_s);
 165
 166 #ifdef Q_OS_WIN
 167     // should be `c:/` instead of `c:`
 168     // Windows "drive letter" is limited to one alphabet
 169     if ((slashIndex == 2) && hasDriveLetter(m_pathStr))
 170         return (m_pathStr.size() == 3) ? Path() : createUnchecked(m_pathStr.left(slashIndex + 1));
 171 #endif
 172     return createUnchecked(m_pathStr.left(slashIndex));
 173 }
 174
 175 QString Path::filename() const
 176 {
 177     const int slashIndex = m_pathStr.lastIndexOf(u'/');
 178     if (slashIndex == -1)
 179         return m_pathStr;
 180
 181     return m_pathStr.mid(slashIndex + 1);
 182 }
 183
 184 QString Path::extension() const
 185 {
 186     const QString suffix = QMimeDatabase().suffixForFileName(m_pathStr);
 187     if (!suffix.isEmpty())
 188         return (u"." + suffix);
 189
 190     const int slashIndex = m_pathStr.lastIndexOf(u'/');
 191     const auto filename = QStringView(m_pathStr).mid(slashIndex + 1);
 192     const int dotIndex = filename.lastIndexOf(u'.', -2);
 193     return ((dotIndex == -1) ? QString() : filename.mid(dotIndex).toString());
 194 }
 195
 196 bool Path::hasExtension(const QStringView ext) const
 197 {
 198     Q_ASSERT(ext.startsWith(u'.') && (ext.size() >= 2));
 199
 200     return m_pathStr.endsWith(ext, Qt::CaseInsensitive);
 201 }
 202
 203 bool Path::hasAncestor(const Path &other) const
 204 {
 205     if (other.isEmpty() || (m_pathStr.size() <= other.m_pathStr.size()))
 206         return false;
 207
 208     return (m_pathStr[other.m_pathStr.size()] == u'/')
 209             && m_pathStr.startsWith(other.m_pathStr, CASE_SENSITIVITY);
 210 }
 211
 212 Path Path::relativePathOf(const Path &childPath) const
 213 {
 214     // If both paths are relative, we assume that they have the same base path
 215     if (isRelative() && childPath.isRelative())
 216         return Path(QDir(QDir::home().absoluteFilePath(m_pathStr)).relativeFilePath(QDir::home().absoluteFilePath(childPath.data())));
 217
 218     return Path(QDir(m_pathStr).relativeFilePath(childPath.data()));
 219 }
 220
 221 void Path::removeExtension()
 222 {
 223     m_pathStr.chop(extension().size());
 224 }
 225
 226 Path Path::removedExtension() const
 227 {
 228     return createUnchecked(m_pathStr.chopped(extension().size()));
 229 }
 230
 231 void Path::removeExtension(const QStringView ext)
 232 {
 233     if (hasExtension(ext))
 234         m_pathStr.chop(ext.size());
 235 }
 236
 237 Path Path::removedExtension(const QStringView ext) const
 238 {
 239     return (hasExtension(ext) ? createUnchecked(m_pathStr.chopped(ext.size())) : *this);
 240 }
 241
 242 QString Path::data() const
 243 {
 244     return m_pathStr;
 245 }
 246
 247 QString Path::toString() const
 248 {
 249     return QDir::toNativeSeparators(m_pathStr);
 250 }
 251
 252 std::filesystem::path Path::toStdFsPath() const
 253 {
 254 #ifdef Q_OS_WIN
 255     return {data().toStdWString(), std::filesystem::path::format::generic_format};
 256 #else
 257     return {data().toStdString(), std::filesystem::path::format::generic_format};
 258 #endif
 259 }
 260
 261 Path &Path::operator/=(const Path &other)
 262 {
 263     *this = *this / other;
 264     return *this;
 265 }
 266
 267 Path &Path::operator+=(const QStringView str)
 268 {
 269     *this = *this + str;
 270     return *this;
 271 }
 272
 273 Path Path::commonPath(const Path &left, const Path &right)
 274 {
 275     if (left.isEmpty() || right.isEmpty())
 276         return {};
 277
 278     const QList<QStringView> leftPathItems = QStringView(left.m_pathStr).split(u'/');
 279     const QList<QStringView> rightPathItems = QStringView(right.m_pathStr).split(u'/');
 280     int commonItemsCount = 0;
 281     qsizetype commonPathSize = 0;
 282     while ((commonItemsCount < leftPathItems.size()) && (commonItemsCount < rightPathItems.size()))
 283     {
 284         const QStringView leftPathItem = leftPathItems[commonItemsCount];
 285         const QStringView rightPathItem = rightPathItems[commonItemsCount];
 286         if (leftPathItem.compare(rightPathItem, CASE_SENSITIVITY) != 0)
 287             break;
 288
 289         ++commonItemsCount;
 290         commonPathSize += leftPathItem.size();
 291     }
 292
 293     if (commonItemsCount > 0)
 294         commonPathSize += (commonItemsCount - 1); // size of intermediate separators
 295
 296     return Path::createUnchecked(left.m_pathStr.left(commonPathSize));
 297 }
 298
 299 Path Path::findRootFolder(const PathList &filePaths)
 300 {
 301     Path rootFolder;
 302     for (const Path &filePath : filePaths)
 303     {
 304         const auto filePathElements = QStringView(filePath.m_pathStr).split(u'/');
 305         // if at least one file has no root folder, no common root folder exists
 306         if (filePathElements.count() <= 1)
 307             return {};
 308
 309         if (rootFolder.isEmpty())
 310             rootFolder.m_pathStr = filePathElements.at(0).toString();
 311         else if (rootFolder.m_pathStr != filePathElements.at(0))
 312             return {};
 313     }
 314
 315     return rootFolder;
 316 }
 317
 318 void Path::stripRootFolder(PathList &filePaths)
 319 {
 320     const Path commonRootFolder = findRootFolder(filePaths);
 321     if (commonRootFolder.isEmpty())
 322         return;
 323
 324     for (Path &filePath : filePaths)
 325         filePath.m_pathStr.remove(0, (commonRootFolder.m_pathStr.size() + 1));
 326 }
 327
 328 void Path::addRootFolder(PathList &filePaths, const Path &rootFolder)
 329 {
 330     Q_ASSERT(!rootFolder.isEmpty());
 331
 332     for (Path &filePath : filePaths)
 333         filePath = rootFolder / filePath;
 334 }
 335
 336 Path Path::createUnchecked(const QString &pathStr)
 337 {
 338     Path path;
 339     path.m_pathStr = pathStr;
 340
 341     return path;
 342 }
 343
 344 bool operator==(const Path &lhs, const Path &rhs)
 345 {
 346     return (lhs.data().compare(rhs.data(), CASE_SENSITIVITY) == 0);
 347 }
 348
 349 Path operator/(const Path &lhs, const Path &rhs)
 350 {
 351     if (rhs.isEmpty())
 352         return lhs;
 353
 354     if (lhs.isEmpty())
 355         return rhs;
 356
 357     return Path(lhs.m_pathStr + u'/' + rhs.m_pathStr);
 358 }
 359
 360 Path operator+(const Path &lhs, const QStringView rhs)
 361 {
 362     return Path(lhs.data() + rhs);
 363 }
 364
 365 QDataStream &operator<<(QDataStream &out, const Path &path)
 366 {
 367     out << path.data();
 368     return out;
 369 }
 370
 371 QDataStream &operator>>(QDataStream &in, Path &path)
 372 {
 373     QString pathStr;
 374     in >> pathStr;
 375     path = Path(pathStr);
 376     return in;
 377 }
 378
 379 std::size_t qHash(const Path &key, const std::size_t seed)
 380 {
 381     return ::qHash(key.data(), seed);
 382 }