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
  41 #if defined(Q_OS_WIN)
  42 const Qt::CaseSensitivity CASE_SENSITIVITY = Qt::CaseInsensitive;
  43 #else
  44 const Qt::CaseSensitivity CASE_SENSITIVITY = Qt::CaseSensitive;
  45 #endif
  46
  47 const int PATHLIST_TYPEID = qRegisterMetaType<PathList>("PathList");
  48
  49 namespace
  50 {
  51     QString cleanPath(const QString &path)
  52     {
  53         const bool hasSeparator = std::any_of(path.cbegin(), path.cend(), [](const QChar c)
  54         {
  55             return (c == u'/') || (c == u'\\');
  56         });
  57         return hasSeparator ? QDir::cleanPath(path) : path;
  58     }
  59 }
  60
  61 Path::Path(const QString &pathStr)
  62     : m_pathStr {cleanPath(pathStr)}
  63 {
  64 }
  65
  66 Path::Path(const std::string &pathStr)
  67     : Path(QString::fromStdString(pathStr))
  68 {
  69 }
  70
  71 bool Path::isValid() const
  72 {
  73     if (isEmpty())
  74         return false;
  75
  76 #if defined(Q_OS_WIN)
  77     const QRegularExpression regex {QLatin1String("[:?\"*<>|]")};
  78 #elif defined(Q_OS_MACOS)
  79     const QRegularExpression regex {QLatin1String("[\\0:]")};
  80 #else
  81     const QRegularExpression regex {QLatin1String("[\\0]")};
  82 #endif
  83     return !m_pathStr.contains(regex);
  84 }
  85
  86 bool Path::isEmpty() const
  87 {
  88     return m_pathStr.isEmpty();
  89 }
  90
  91 bool Path::isAbsolute() const
  92 {
  93     return QDir::isAbsolutePath(m_pathStr);
  94 }
  95
  96 bool Path::isRelative() const
  97 {
  98     return QDir::isRelativePath(m_pathStr);
  99 }
 100
 101 bool Path::exists() const
 102 {
 103     return !isEmpty() && QFileInfo::exists(m_pathStr);
 104 }
 105
 106 Path Path::rootItem() const
 107 {
 108     const int slashIndex = m_pathStr.indexOf(QLatin1Char('/'));
 109     if (slashIndex < 0)
 110         return *this;
 111
 112     if (slashIndex == 0) // *nix absolute path
 113         return createUnchecked(QLatin1String("/"));
 114
 115     return createUnchecked(m_pathStr.left(slashIndex));
 116 }
 117
 118 Path Path::parentPath() const
 119 {
 120     const int slashIndex = m_pathStr.lastIndexOf(QLatin1Char('/'));
 121     if (slashIndex == -1)
 122         return {};
 123
 124     if (slashIndex == 0) // *nix absolute path
 125         return (m_pathStr.size() == 1) ? Path() : createUnchecked(QLatin1String("/"));
 126
 127     return createUnchecked(m_pathStr.left(slashIndex));
 128 }
 129
 130 QString Path::filename() const
 131 {
 132     const int slashIndex = m_pathStr.lastIndexOf(u'/');
 133     if (slashIndex == -1)
 134         return m_pathStr;
 135
 136     return m_pathStr.mid(slashIndex + 1);
 137 }
 138
 139 QString Path::extension() const
 140 {
 141     const QString suffix = QMimeDatabase().suffixForFileName(m_pathStr);
 142     if (!suffix.isEmpty())
 143         return (QLatin1String(".") + suffix);
 144
 145     const int slashIndex = m_pathStr.lastIndexOf(QLatin1Char('/'));
 146     const auto filename = QStringView(m_pathStr).mid(slashIndex + 1);
 147     const int dotIndex = filename.lastIndexOf(QLatin1Char('.'), -2);
 148     return ((dotIndex == -1) ? QString() : filename.mid(dotIndex).toString());
 149 }
 150
 151 bool Path::hasExtension(const QString &ext) const
 152 {
 153     Q_ASSERT(ext.startsWith(QLatin1Char('.')) && (ext.size() >= 2));
 154
 155     return m_pathStr.endsWith(ext, Qt::CaseInsensitive);
 156 }
 157
 158 bool Path::hasAncestor(const Path &other) const
 159 {
 160     if (other.isEmpty() || (m_pathStr.size() <= other.m_pathStr.size()))
 161         return false;
 162
 163     return (m_pathStr[other.m_pathStr.size()] == QLatin1Char('/'))
 164             && m_pathStr.startsWith(other.m_pathStr, CASE_SENSITIVITY);
 165 }
 166
 167 Path Path::relativePathOf(const Path &childPath) const
 168 {
 169     // If both paths are relative, we assume that they have the same base path
 170     if (isRelative() && childPath.isRelative())
 171         return Path(QDir(QDir::home().absoluteFilePath(m_pathStr)).relativeFilePath(QDir::home().absoluteFilePath(childPath.data())));
 172
 173     return Path(QDir(m_pathStr).relativeFilePath(childPath.data()));
 174 }
 175
 176 void Path::removeExtension()
 177 {
 178     m_pathStr.chop(extension().size());
 179 }
 180
 181 void Path::removeExtension(const QString &ext)
 182 {
 183     if (hasExtension(ext))
 184         m_pathStr.chop(ext.size());
 185 }
 186
 187 QString Path::data() const
 188 {
 189     return m_pathStr;
 190 }
 191
 192 QString Path::toString() const
 193 {
 194     return QDir::toNativeSeparators(m_pathStr);
 195 }
 196
 197 Path &Path::operator/=(const Path &other)
 198 {
 199     *this = *this / other;
 200     return *this;
 201 }
 202
 203 Path &Path::operator+=(const QString &str)
 204 {
 205     *this = *this + str;
 206     return *this;
 207 }
 208
 209 Path &Path::operator+=(const std::string &str)
 210 {
 211     return (*this += QString::fromStdString(str));
 212 }
 213
 214 Path Path::commonPath(const Path &left, const Path &right)
 215 {
 216     if (left.isEmpty() || right.isEmpty())
 217         return {};
 218
 219     const QList<QStringView> leftPathItems = QStringView(left.m_pathStr).split(u'/');
 220     const QList<QStringView> rightPathItems = QStringView(right.m_pathStr).split(u'/');
 221     int commonItemsCount = 0;
 222     qsizetype commonPathSize = 0;
 223     while ((commonItemsCount < leftPathItems.size()) && (commonItemsCount < rightPathItems.size()))
 224     {
 225         const QStringView leftPathItem = leftPathItems[commonItemsCount];
 226         const QStringView rightPathItem = rightPathItems[commonItemsCount];
 227         if (leftPathItem.compare(rightPathItem, CASE_SENSITIVITY) != 0)
 228             break;
 229
 230         ++commonItemsCount;
 231         commonPathSize += leftPathItem.size();
 232     }
 233
 234     if (commonItemsCount > 0)
 235         commonPathSize += (commonItemsCount - 1); // size of intermediate separators
 236
 237     return Path::createUnchecked(left.m_pathStr.left(commonPathSize));
 238 }
 239
 240 Path Path::findRootFolder(const PathList &filePaths)
 241 {
 242     Path rootFolder;
 243     for (const Path &filePath : filePaths)
 244     {
 245         const auto filePathElements = QStringView(filePath.m_pathStr).split(u'/');
 246         // if at least one file has no root folder, no common root folder exists
 247         if (filePathElements.count() <= 1)
 248             return {};
 249
 250         if (rootFolder.isEmpty())
 251             rootFolder.m_pathStr = filePathElements.at(0).toString();
 252         else if (rootFolder.m_pathStr != filePathElements.at(0))
 253             return {};
 254     }
 255
 256     return rootFolder;
 257 }
 258
 259 void Path::stripRootFolder(PathList &filePaths)
 260 {
 261     const Path commonRootFolder = findRootFolder(filePaths);
 262     if (commonRootFolder.isEmpty())
 263         return;
 264
 265     for (Path &filePath : filePaths)
 266         filePath.m_pathStr = filePath.m_pathStr.mid(commonRootFolder.m_pathStr.size() + 1);
 267 }
 268
 269 void Path::addRootFolder(PathList &filePaths, const Path &rootFolder)
 270 {
 271     Q_ASSERT(!rootFolder.isEmpty());
 272
 273     for (Path &filePath : filePaths)
 274         filePath = rootFolder / filePath;
 275 }
 276
 277 Path Path::createUnchecked(const QString &pathStr)
 278 {
 279     Path path;
 280     path.m_pathStr = pathStr;
 281
 282     return path;
 283 }
 284
 285 bool operator==(const Path &lhs, const Path &rhs)
 286 {
 287     return (lhs.data().compare(rhs.data(), CASE_SENSITIVITY) == 0);
 288 }
 289
 290 bool operator!=(const Path &lhs, const Path &rhs)
 291 {
 292     return !(lhs == rhs);
 293 }
 294
 295 Path operator/(const Path &lhs, const Path &rhs)
 296 {
 297     if (rhs.isEmpty())
 298         return lhs;
 299
 300     if (lhs.isEmpty())
 301         return rhs;
 302
 303     return Path(lhs.m_pathStr + QLatin1Char('/') + rhs.m_pathStr);
 304 }
 305
 306 Path operator+(const Path &lhs, const QString &rhs)
 307 {
 308     return Path(lhs.m_pathStr + rhs);
 309 }
 310
 311 Path operator+(const Path &lhs, const char rhs[])
 312 {
 313     return lhs + QString::fromLatin1(rhs);
 314 }
 315
 316 Path operator+(const Path &lhs, const std::string &rhs)
 317 {
 318     return lhs + QString::fromStdString(rhs);
 319 }
 320
 321 QDataStream &operator<<(QDataStream &out, const Path &path)
 322 {
 323     out << path.data();
 324     return out;
 325 }
 326
 327 QDataStream &operator>>(QDataStream &in, Path &path)
 328 {
 329     QString pathStr;
 330     in >> pathStr;
 331     path = Path(pathStr);
 332     return in;
 333 }
 334
 335 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
 336 std::size_t qHash(const Path &key, const std::size_t seed)
 337 #else
 338 uint qHash(const Path &key, const uint seed)
 339 #endif
 340 {
 341     return ::qHash(key.data(), seed);
 342 }