src/Git/TGitPath.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2018 - TortoiseGit
   4 // Copyright (C) 2003-2008, 2014 - TortoiseSVN
   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 Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #pragma once
  22 #include "gittype.h"
  23
  24 #define PARENT_MASK   0xFFFFFF
  25 #define MERGE_MASK      (0x1000000)
  26
  27 class CTGitPath
  28 {
  29 public:
  30         CTGitPath(void);
  31 #ifdef GMOCK_INCLUDE_GMOCK_GMOCK_H_
  32         virtual ~CTGitPath(void);
  33 #else
  34         ~CTGitPath(void);
  35 #endif
  36         CTGitPath(const CString& sUnknownPath);
  37         CTGitPath(const CString& sUnknownPath, bool bIsDirectory);
  38         int m_Stage;
  39         int m_ParentNo;
  40
  41         enum Actions : unsigned int
  42         {
  43                 LOGACTIONS_ADDED        = 0x00000001,
  44                 LOGACTIONS_MODIFIED     = 0x00000002,
  45                 LOGACTIONS_REPLACED     = 0x00000004,
  46                 LOGACTIONS_DELETED      = 0x00000008,
  47                 LOGACTIONS_UNMERGED = 0x00000010,
  48                 LOGACTIONS_COPY         = 0x00000040,
  49                 LOGACTIONS_MERGED   = 0x00000080,
  50                 LOGACTIONS_ASSUMEVALID = 0x00000200,
  51                 LOGACTIONS_SKIPWORKTREE = 0x00000400,
  52                 LOGACTIONS_MISSING  = 0x00001000,
  53                 LOGACTIONS_UNVER        = 0x80000000,
  54                 LOGACTIONS_IGNORE       = 0x40000000,
  55
  56                 // For log filter only
  57                 LOGACTIONS_HIDE         = 0x20000000,
  58                 LOGACTIONS_GRAY         = 0x10000000,
  59         };
  60
  61         CString m_StatAdd;
  62         CString m_StatDel;
  63         unsigned int            m_Action;
  64         bool    m_Checked;
  65         unsigned int ParserAction(BYTE action);
  66         unsigned int ParserAction(git_delta_t action);
  67         CString GetActionName() const;
  68         static CString GetActionName(unsigned int action);
  69         /**
  70          * Set the path as an UTF8 string with forward slashes
  71          */
  72         void SetFromGit(const char* pPath);
  73         void SetFromGit(const char* pPath, bool bIsDirectory);
  74         void SetFromGit(const TCHAR* pPath, bool bIsDirectory);
  75         void SetFromGit(const CString& sPath, CString* oldPath = nullptr, int* bIsDirectory = nullptr);
  76
  77         /**
  78          * Set the path as UNICODE with backslashes
  79          */
  80         void SetFromWin(LPCTSTR pPath);
  81         void SetFromWin(const CString& sPath);
  82         void SetFromWin(LPCTSTR pPath, bool bIsDirectory);
  83         void SetFromWin(const CString& sPath, bool bIsDirectory);
  84         /**
  85          * Set the path from an unknown source.
  86          */
  87         void SetFromUnknown(const CString& sPath);
  88         /**
  89          * Returns the path in Windows format, i.e. with backslashes
  90          */
  91         LPCTSTR GetWinPath() const;
  92         /**
  93          * Returns the path in Windows format, i.e. with backslashes
  94          */
  95         const CString& GetWinPathString() const;
  96         /**
  97          * Returns the path with forward slashes.
  98          */
  99         const CString& GetGitPathString() const;
 100
 101         const CString& GetGitOldPathString() const;
 102
 103         /**
 104          * Returns the path for showing in an UI.
 105          *
 106          * URL's are returned with forward slashes, unescaped if necessary
 107          * Paths are returned with backward slashes
 108          */
 109         const CString& GetUIPathString() const;
 110         /**
 111          * Returns true if the path points to a directory
 112          */
 113         bool IsDirectory() const;
 114
 115         CTGitPath GetSubPath(const CTGitPath &root);
 116
 117         /**
 118          * Returns the directory. If the path points to a directory, then the path
 119          * is returned unchanged. If the path points to a file, the path to the
 120          * parent directory is returned.
 121          */
 122         CTGitPath GetDirectory() const;
 123         /**
 124         * Returns the the directory which contains the item the path refers to.
 125         * If the path is a directory, then this returns the directory above it.
 126         * If the path is to a file, then this returns the directory which contains the path
 127         * parent directory is returned.
 128         */
 129         CTGitPath GetContainingDirectory() const;
 130         /**
 131          * Get the 'root path' (e.g. "c:\") - Used to pass to GetDriveType
 132          */
 133         CString GetRootPathString() const;
 134         /**
 135          * Returns the filename part of the full path.
 136          * \remark don't call this for directories.
 137          */
 138         CString GetFilename() const;
 139         CString GetBaseFilename() const;
 140         /**
 141          * Returns the item's name without the full path.
 142          */
 143         CString GetFileOrDirectoryName() const;
 144         /**
 145          * Returns the item's name without the full path, unescaped if necessary.
 146          */
 147         CString GetUIFileOrDirectoryName() const;
 148         /**
 149          * Returns the file extension, including the dot.
 150          * \remark Returns an empty string for directories
 151          */
 152         CString GetFileExtension() const;
 153
 154         void UpdateCase();
 155
 156         bool IsEmpty() const;
 157         void Reset();
 158         /**
 159          * Checks if two paths are equal. The slashes are taken care of.
 160          */
 161         bool IsEquivalentTo(const CTGitPath& rhs) const;
 162         bool IsEquivalentToWithoutCase(const CTGitPath& rhs) const;
 163         bool operator==(const CTGitPath& x) const {return IsEquivalentTo(x);}
 164
 165         /**
 166          * Checks if \c possibleDescendant is a child of this path.
 167          */
 168         bool IsAncestorOf(const CTGitPath& possibleDescendant) const;
 169         /**
 170          * Get a string representing the file path, optionally with a base
 171          * section stripped off the front
 172          * Returns a string with fwdslash paths
 173          */
 174         CString GetDisplayString(const CTGitPath* pOptionalBasePath = nullptr) const;
 175         /**
 176          * Compares two paths. Slash format is irrelevant.
 177          */
 178         static int Compare(const CTGitPath& left, const CTGitPath& right);
 179
 180         /** As PredLeftLessThanRight, but for checking if paths are equivalent
 181          */
 182         static bool PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right);
 183
 184         /** Checks if the left path is pointing to the same working copy path as the right.
 185          * The same wc path means the paths are equivalent once all the admin dir path parts
 186          * are removed. This is used in the TGitCache crawler to filter out all the 'duplicate'
 187          * paths to crawl.
 188          */
 189         static bool PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right);
 190
 191         static bool CheckChild(const CTGitPath &parent, const CTGitPath& child);
 192
 193         /**
 194          * appends a string to this path.
 195          *\remark - missing slashes are not added - this is just a string concatenation, but with
 196          * preservation of the proper caching behavior.
 197          * If you want to join a file- or directory-name onto the path, you should use AppendPathString
 198          */
 199         void AppendRawString(const CString& sAppend);
 200
 201         /**
 202         * appends a part of a path to this path.
 203         *\remark - missing slashes are dealt with properly. Don't use this to append a file extension, for example
 204         *
 205         */
 206         void AppendPathString(const CString& sAppend);
 207
 208         /**
 209          * Get the file modification time - returns zero for files which don't exist
 210          */
 211         __int64 GetLastWriteTime(bool force = false) const;
 212
 213         /**
 214          * Get the file size. Returns zero for directories or files that don't exist.
 215          */
 216         __int64 GetFileSize() const;
 217
 218         bool IsReadOnly() const;
 219
 220         /**
 221          * Checks if the path really exists.
 222          */
 223         bool Exists() const;
 224
 225         /**
 226          * Deletes the file/folder
 227          * \param bTrash if true, uses the Windows trash bin when deleting.
 228          */
 229         bool Delete(bool bTrash, bool bShowErrorUI) const;
 230
 231         /**
 232          * Checks if a git admin directory is present. For files, the check
 233          * is done in the same directory. For folders, it checks if the folder itself
 234          * contains an admin directory.
 235          */
 236         bool HasAdminDir(CString* projectTopDir = nullptr, bool force = false) const;
 237         bool HasSubmodules() const;
 238         bool HasGitSVNDir() const;
 239         bool IsBisectActive() const;
 240         bool IsMergeActive() const;
 241         bool HasStashDir() const;
 242         bool HasRebaseApply() const;
 243
 244         bool IsWCRoot() const;
 245
 246         int  GetAdminDirMask() const;
 247
 248         bool IsRegisteredSubmoduleOfParentProject(CString* parentProjectRoot = nullptr) const;
 249
 250         /**
 251          * Checks if the path point to or below a git admin directory (.Git).
 252          */
 253         bool IsAdminDir() const;
 254
 255         /**
 256          * Checks if the path or URL is valid on Windows.
 257          * A path is valid if conforms to the specs in the windows API.
 258          * An URL is valid if the path checked out from it is valid
 259          * on windows. That means an URL which is valid according to the WWW specs
 260          * isn't necessarily valid as a windows path (e.g. http://myserver.com/repos/file:name
 261          * is a valid URL, but the path is illegal on windows ("file:name" is illegal), so
 262          * this function would return \c false for that URL).
 263          */
 264         bool IsValidOnWindows() const;
 265
 266         CString GetAbbreviatedRename() const;
 267
 268 private:
 269         // All these functions are const, and all the data
 270         // is mutable, in order that the hidden caching operations
 271         // can be carried out on a const CTGitPath object, which is what's
 272         // likely to be passed between functions
 273         // The public 'SetFromxxx' functions are not const, and so the proper
 274         // const-correctness semantics are preserved
 275         void SetFwdslashPath(const CString& sPath) const;
 276         void SetBackslashPath(const CString& sPath) const;
 277         void EnsureBackslashPathSet() const;
 278         void EnsureFwdslashPathSet() const;
 279
 280 public:
 281         /**
 282          * Marks a path as a file by unsetting the cached IsDirectory status
 283          * Used while diffing commits where a submodule changed to a file
 284          */
 285         void UnsetDirectoryStatus() { m_bIsDirectory = false; }
 286
 287 private:
 288         /**
 289          * Adds the required trailing slash to local root paths such as 'C:'
 290          */
 291         void SanitizeRootPath(CString& sPath, bool bIsForwardPath) const;
 292
 293 #ifdef GMOCK_INCLUDE_GMOCK_GMOCK_H_
 294 protected:
 295         virtual void UpdateAttributes() const;
 296 private:
 297 #else
 298         void UpdateAttributes() const;
 299 #endif
 300
 301         bool HasStashDir(const CString& adminDirPath) const;
 302
 303 private:
 304         mutable CString m_sBackslashPath;
 305         mutable CString m_sLongBackslashPath;
 306         mutable CString m_sFwdslashPath;
 307         mutable CString m_sUIPath;
 308         mutable CString m_sProjectRoot;
 309
 310         //used for rename case
 311         mutable CString m_sOldFwdslashPath;
 312
 313         // Have we yet determined if this is a directory or not?
 314         mutable bool m_bDirectoryKnown;
 315         mutable bool m_bIsDirectory;
 316         mutable bool m_bLastWriteTimeKnown;
 317         mutable __int64 m_lastWriteTime;
 318         mutable __int64 m_fileSize;
 319         mutable bool m_bIsReadOnly;
 320         mutable bool m_bHasAdminDirKnown;
 321         mutable bool m_bHasAdminDir;
 322         mutable bool m_bIsValidOnWindowsKnown;
 323         mutable bool m_bIsValidOnWindows;
 324         mutable bool m_bIsAdminDirKnown;
 325         mutable bool m_bIsAdminDir;
 326         mutable bool m_bIsWCRootKnown;
 327         mutable bool m_bIsWCRoot;
 328         mutable bool m_bExists;
 329         mutable bool m_bExistsKnown;
 330
 331         friend bool operator<(const CTGitPath& left, const CTGitPath& right);
 332 };
 333 /**
 334  * Compares two paths and return true if left is earlier in sort order than right
 335  * (Uses CTGitPath::Compare logic, but is suitable for std::sort and similar)
 336  */
 337  bool operator<(const CTGitPath& left, const CTGitPath& right);
 338
 339
 340 //////////////////////////////////////////////////////////////////////////
 341
 342 /**
 343  * \ingroup Utils
 344  * This class represents a list of paths
 345  */
 346 class CTGitPathList
 347 {
 348 public:
 349         CTGitPathList();
 350         // A constructor which allows a path list to be easily built with one initial entry in
 351         explicit CTGitPathList(const CTGitPath& firstEntry);
 352         unsigned int m_Action;
 353
 354 public:
 355         void AddPath(const CTGitPath& newPath);
 356         bool LoadFromFile(const CTGitPath& filename);
 357         bool WriteToFile(const CString& sFilename, bool bANSI = false) const;
 358         const CTGitPath* LookForGitPath(const CString& path);
 359         int     ParserFromLog(BYTE_VECTOR &log, bool parseDeletes = false);
 360         int ParserFromLsFile(BYTE_VECTOR &out,bool staged=true);
 361         int FillUnRev(unsigned int Action, const CTGitPathList* filterlist = nullptr, CString* err = nullptr);
 362         int FillBasedOnIndexFlags(unsigned short flag, unsigned short flagextended, const CTGitPathList* filterlist = nullptr);
 363         unsigned int GetAction();
 364         /**
 365          * Load from the path argument string, when the 'path' parameter is used
 366          * This is a list of paths, with '*' between them
 367          */
 368         void LoadFromAsteriskSeparatedString(const CString& sPathString);
 369         CString CreateAsteriskSeparatedString() const;
 370
 371         int GetCount() const;
 372         bool IsEmpty() const;
 373         void Clear();
 374         const CTGitPath& operator[](INT_PTR index) const;
 375         bool AreAllPathsFiles() const;
 376         bool AreAllPathsFilesInOneDirectory() const;
 377         /**
 378          * returns the directory which all items have in common.
 379          * if not all paths are in the same directory, then
 380          * an empty path is returned
 381          */
 382         CTGitPath GetCommonDirectory() const;
 383         /**
 384          * returns the root path of all paths in the list.
 385          * only returns an empty path if not all paths are on
 386          * the same drive/root.
 387          */
 388         CTGitPath GetCommonRoot() const;
 389         void SortByPathname(bool bReverse = false);
 390         /**
 391          * Delete all the files in the list, then clear the list.
 392          * \param bTrash if true, the items are deleted using the Windows trash bin
 393          * \param bShowErrorUI if true, show error dialog box when error occurs.
 394          */
 395         void DeleteAllFiles(bool bTrash, bool bFilesOnly = true, bool bShowErrorUI = false);
 396         static bool DeleteViaShell(LPCTSTR path, bool useTrashbin, bool bShowErrorUI);
 397         /** Remove duplicate entries from the list (sorts the list as a side-effect */
 398         void RemoveDuplicates();
 399         /** Removes all paths which are on or in a git admin directory */
 400         void RemoveAdminPaths();
 401         void RemovePath(const CTGitPath& path);
 402         void RemoveItem(CTGitPath &path);
 403         /**
 404          * Removes all child items and leaves only the top folders. Useful if you
 405          * create the list to remove them (i.e. if you remove a parent folder, the
 406          * child files and folders don't have to be deleted anymore)
 407          */
 408         void RemoveChildren();
 409
 410         /** Checks if two CTGitPathLists are the same */
 411         bool IsEqual(const CTGitPathList& list);
 412
 413         typedef std::vector<CTGitPath> PathVector;
 414         PathVector m_paths;
 415         // If the list contains just files in one directory, then
 416         // this contains the directory name
 417         mutable CTGitPath m_commonBaseDirectory;
 418 };