gitRepo.cpp

Go to the documentation of this file.

/** \file gitRepo.cpp
  * \author Jared R. Males
  * \brief Interrogate the current state of a git repository (definitions)
  * \ingroup utils_files
  */
 
//***********************************************************************//
// Copyright 2021 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "mxError.hpp"
#include "sys/gitRepo.hpp"
 
#include "ipc/processInterface.hpp"
#include "ioutils/stringUtils.hpp"
#include "ioutils/fileUtils.hpp"
 
 
namespace mx
{
namespace sys 
{
   
gitRepo::gitRepo()
{
}
 
gitRepo::gitRepo(const std::string & d)
{
   dir(d);
}
 
void gitRepo::dir(const std::string & d)
{
   m_dir = d;
   
   getGitName();
   getGitHash();
   getGitModified();
   getGitFileState();
   
}
 
std::string gitRepo::dir()
{
   return m_dir;
}
 
std::string gitRepo::gitDir()
{
   return m_dir + "/.git";
}
 
int gitRepo::getGitName()
{
   int retVal;
   std::vector<std::string> stdOut, stdErr;
   
   if( ipc::runCommand( retVal, stdOut, stdErr, {"git", "--git-dir=" + gitDir(), "rev-parse", "--show-toplevel"}) < 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error running git command");
      return -1;
   }
   
   if(stdErr.size() > 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error returned by git");
 
      for(size_t n=0; n< stdErr.size(); ++n)
      {
         std::cerr << "err: " << stdErr[n] << "\n";
      }
      
      return -1;
   }
 
   if(stdOut.size() < 1)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "nothing returned by git");
      return -1;
   }
   
   if(stdOut.size() > 1)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "too much returned by git");
      return -1;
   }
   
   m_name = ioutils::pathFilename(stdOut[0]);
   
   return 0;
}
 
int gitRepo::getGitHash()
{
   int retVal;
   std::vector<std::string> stdOut, stdErr;
   
   if(ipc::runCommand( retVal, stdOut, stdErr, {"git", "--git-dir=" + gitDir(), "--work-tree=" + dir(), "log", "-1", "--format=%H"}) < 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error running git command");
      return -1;
   }
 
   if(stdErr.size() > 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error returned by git");
 
      for(size_t n=0; n< stdErr.size(); ++n)
      {
         std::cerr << "err: " << stdErr[n] << "\n";
      }
      
      return -1;
   }
 
   if(stdOut.size() < 1)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "nothing returned by git");
      return -1;
   }
   
   if(stdOut.size() > 1)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "too much returned by git");
      return -1;
   }
   
   m_hash = stdOut[0];
   
   return 0;
}
 
int gitRepo::getGitModified()
{
   int retVal;
   std::vector<std::string> stdOut, stdErr;
   
   if(ipc::runCommand( retVal, stdOut, stdErr, {"git", "--git-dir=" + gitDir(), "--work-tree=" + dir(), "diff-index", "HEAD", "--"}) < 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error running git command");
      return -1;
   }
   
   if(stdErr.size() > 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error returned by git");
      for(size_t n=0; n< stdErr.size(); ++n)
      {
         std::cerr << "err: " << stdErr[n] << "\n";
      }
      
      return -1;
   }
 
   m_modified = (stdOut.size() > 0); //rv;
   
   return 0;
}
 
int gitRepo::getGitFileState()
{
   int retVal;
   std::vector<std::string> stdOut, stdErr;
   
   if(ipc::runCommand(retVal, stdOut, stdErr, {"git", "--git-dir=" + gitDir(), "--work-tree=" + dir(), "status"}) < 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error running git command");
      return -1;
   }
 
   if(stdErr.size() > 0)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "error returned by git");
 
      for(size_t n=0; n< stdErr.size(); ++n)
      {
         std::cerr << "err: " << stdErr[n] << "\n";
      }
      
      return -1;
   }
   
   if(stdOut.size() < 1)
   {
      mxError("mx::sys::gitRepo::getGitName", MXE_PROCERR, "nothing returned by git");
      return -1;
   }
   
   m_modifiedFiles.clear();
   m_deletedFiles.clear();
   m_renamedFiles.clear();
   m_renamedFiles2.clear();
   m_untrackedFiles.clear();
   
   for(size_t n=0; n < stdOut.size(); ++n)
   {
      if(stdOut[n].find("On b") != std::string::npos)
      {
         m_branch = stdOut[n].substr(sizeof("On branch"));
      }
      else if(stdOut[n].find("Changes not") != std::string::npos)
      {
         //Changes not staged for commit
         
         ++n;
         while(stdOut[n].size() > 0)
         {
            if(n >= stdOut.size()) break;
            
            if(stdOut[n].find("mod") != std::string::npos )
            {
               m_modifiedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("modified:"))));
            }
            else if(stdOut[n].find("del") != std::string::npos )
            {
               m_deletedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("deleted:"))));
            }
            else if(stdOut[n].find("ren") != std::string::npos )
            {
               size_t a = stdOut[n].find(" -> ");
               
               m_renamedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("renamed:"), a-sizeof("renamed:"))));
               m_renamedFiles2.insert(ioutils::removeWhiteSpace(stdOut[n].substr(a + sizeof(" ->"))));
            }
            ++n;
         }
      }
      else if(stdOut[n].find("Changes to") != std::string::npos)
      {
         //Changes to be committed
         
         ++n;
         while(stdOut[n].size() > 0)
         {
            if(n >= stdOut.size()) break;
            
            if(stdOut[n].find("mod") != std::string::npos )
            {
               m_modifiedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("modified:"))));
            }
            else if(stdOut[n].find("del") != std::string::npos )
            {
               m_deletedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("deleted:"))));
            }
            else if(stdOut[n].find("ren") != std::string::npos )
            {
               size_t a = stdOut[n].find(" -> ");
               
               m_renamedFiles.insert(ioutils::removeWhiteSpace(stdOut[n].substr(sizeof("renamed:    "), a-sizeof("renamed:"))));
               m_renamedFiles2.insert(ioutils::removeWhiteSpace(stdOut[n].substr(a + sizeof(" ->"))));
            }
            ++n;
         }
      }
      else if(stdOut[n].find("Untracked") != std::string::npos)
      {
         //Untracked files:
         
         ++n;
         ++n;
         while(stdOut[n].size() > 0)
         {
            if(n >= stdOut.size()) break;
            m_untrackedFiles.insert(ioutils::removeWhiteSpace(stdOut[n]));
            ++n;
         }
      }
   }
      
   return 0;
}
 
std::string gitRepo::name()
{
   return m_name;
}
 
std::string gitRepo::branch()
{
   return m_branch;
}
 
std::string gitRepo::hash()
{
   return m_hash;
}
 
bool gitRepo::modified()
{
   return m_modified;
}
 
bool gitRepo::isNotCommitted(const std::string & file)
{
   return ( m_modifiedFiles.count(file) + m_deletedFiles.count(file) + m_renamedFiles.count(file) + 
                m_renamedFiles2.count(file) + m_untrackedFiles.count(file) > 0);
}
 
}
}