src/Utils/Hooks.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2011-2014 - TortoiseGit
   4 // Copyright (C) 2006-2008 - 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 #pragma once
  21 #include <map>
  22 #include "registry.h"
  23 #include "TGitPath.h"
  24 #include "GitRev.h"
  25 #include "GitStatus.h"
  26
  27 /**
  28  * \ingroup TortoiseProc
  29  * enumeration of all client hook types
  30  */
  31 typedef enum hooktype
  32 {
  33         unknown_hook,
  34         start_commit_hook,
  35         pre_commit_hook,
  36         post_commit_hook,
  37         issue_tracker_hook,
  38         pre_push_hook,
  39         post_push_hook,
  40 } hooktype;
  41
  42 /**
  43  * \ingroup TortoiseProc
  44  * helper class, used as the key to the std::map we store
  45  * the data for the client hook scripts in.
  46  */
  47 class hookkey
  48 {
  49 public:
  50         hooktype                htype;
  51         CTGitPath               path;
  52
  53         bool operator < (const hookkey& hk) const
  54         {
  55                 if (htype == hk.htype)
  56                         return (path < hk.path);
  57                 else
  58                         return htype < hk.htype;
  59         }
  60 };
  61
  62 /**
  63  * \ingroup TortoiseProc
  64  * helper struct, used as the value to the std::map we
  65  * store the data for the client hook scripts in.
  66  */
  67 typedef struct hookcmd
  68 {
  69         CString                 commandline;
  70         bool                    bWait;
  71         bool                    bShow;
  72 } hookcmd;
  73
  74 typedef std::map<hookkey, hookcmd>::iterator hookiterator;
  75
  76 /**
  77  * \ingroup TortoiseProc
  78  * Singleton class which deals with the client hook scripts.
  79  */
  80 class CHooks : public std::map<hookkey, hookcmd>
  81 {
  82 private:
  83         CHooks();
  84         ~CHooks();
  85         void AddPathParam(CString& sCmd, const CTGitPathList& pathList);
  86         void AddCWDParam(CString& sCmd, const CTGitPathList& pathList);
  87         void AddErrorParam(CString& sCmd, const CString& error);
  88         void AddParam(CString& sCmd, const CString& param);
  89         CTGitPath AddMessageFileParam(CString& sCmd, const CString& message);
  90 public:
  91         /// Create the singleton. Call this at the start of the program.
  92         static bool                     Create();
  93         /// Returns the singleton instance
  94         static CHooks&          Instance();
  95         /// Destroys the singleton object. Call this at the end of the program.
  96         static void                     Destroy();
  97
  98 public:
  99         /// Saves the hook script information to the registry.
 100         bool                            Save();
 101         /**
 102          * Removes the hook script identified by \c key. To make the change persistent
 103          * call Save().
 104          */
 105         bool                            Remove(const hookkey &key);
 106         /**
 107          * Adds a new hook script. To make the change persistent, call Save().
 108          */
 109         void                            Add(hooktype ht, const CTGitPath& Path, LPCTSTR szCmd,
 110                                                         bool bWait, bool bShow);
 111
 112         /// returns the string representation of the hook type.
 113         static CString          GetHookTypeString(hooktype t);
 114         /// returns the hooktype from a string representation of the same.
 115         static hooktype         GetHookType(const CString& s);
 116
 117         /**
 118          * Executes the Start-Commit-Hook that first matches one of the paths in
 119          * \c pathList.
 120          * \param pathList a list of paths to look for the hook scripts
 121          * \param message a commit message
 122          * \param exitcode on return, contains the exit code of the hook script
 123          * \param error the data the hook script outputs to stderr
 124          * \remark the string "%PATHS% in the command line of the hook script is
 125          * replaced with the path to a temporary file which contains a list of files
 126          * in \c pathList, separated by newlines. The hook script can parse this
 127          * file to get all the paths the commit is about to be done on.
 128          * The string %MESSAGEFILE% is replaced with path to temporary file containing
 129          * \c message. If the script finishes successfully, contents of this file
 130          * is read back into \c message parameter.
 131          */
 132         bool                            StartCommit(const CTGitPathList& pathList, CString& message,
 133                                                                         DWORD& exitcode, CString& error);
 134         /**
 135          * Executes the Pre-Commit-Hook that first matches one of the paths in
 136          * \c pathList.
 137          * \param pathList a list of paths to look for the hook scripts
 138          * \param message the commit message
 139          * \param exitcode on return, contains the exit code of the hook script
 140          * \param error the data the hook script outputs to stderr
 141          * \remark the string "%PATHS% in the command line of the hook script is
 142          * replaced with the path to a temporary file which contains a list of files
 143          * in \c pathList, separated by newlines. The hook script can parse this
 144          * file to get all the paths the update is about to be done on.
 145          */
 146         bool                            PreCommit(const CTGitPathList& pathList,
 147                                                                         const CString& message, DWORD& exitcode,
 148                                                                         CString& error);
 149         /**
 150          * Executes the Post-Commit-Hook that first matches one of the paths in
 151          * \c pathList.
 152          * \param pathList a list of paths to look for the hook scripts
 153          * \param message the commit message
 154          * \param rev the revision the commit was done to
 155          * \param exitcode on return, contains the exit code of the hook script
 156          * \param error the data the hook script outputs to stderr
 157          * \remark the string "%PATHS% in the command line of the hook script is
 158          * replaced with the path to a temporary file which contains a list of files
 159          * in \c pathList, separated by newlines. The hook script can parse this
 160          * file to get all the paths the commit is about to be done on.
 161          */
 162         bool                            PostCommit(const CTGitPathList& pathList,
 163                                                                         const GitRev& rev, const CString& message,
 164                                                                         DWORD& exitcode, CString& error);
 165
 166         bool    PrePush(const CTGitPathList& pathList,DWORD& exitcode, CString& error);
 167         bool    PostPush(const CTGitPathList& pathList,DWORD& exitcode, CString& error);
 168 private:
 169         /**
 170          * Starts a new process, specified in \c cmd.
 171          * \param error the data the process writes to stderr
 172          * \param bWait if true, then this method waits until the created process has finished. If false, then the return
 173          * value will always be 0 and \c error will be an empty string.
 174          * \param bShow set to true if the process should be started visible.
 175          * \return the exit code of the process if \c bWait is true, zero otherwise.
 176          */
 177         DWORD                           RunScript(CString cmd, LPCTSTR currentDir, CString& error, bool bWait, bool bShow);
 178         /**
 179          * Find the hook script information for the hook type \c t which matches a
 180          * path in \c pathList.
 181          */
 182         hookiterator            FindItem(hooktype t, const CTGitPathList& pathList);
 183         static CHooks *         m_pInstance;
 184 };