/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/upgrader

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_upgrader
#define inlib_upgrader

#include "sys/dir"
#include "sys/file"
#include "smanip"
#include "system"
#include "file"

namespace inlib {

class upgrader {
private:
  class upgrade_visitor : public virtual dir::visitor {
  public:
    virtual bool directory(const std::string& aString,bool& aProcess) {
      aProcess = true;
      std::string p,n,s;
      path_name_suffix(aString,p,n,s);
      if((n=="CVS")||(n==".svn")) aProcess = false;
      return true;
    }
    virtual bool file(const std::string& aString) {
      return m_upgrader.upgrade_file(aString);
    }
  public:
    upgrade_visitor(upgrader& a_upgrader):m_upgrader(a_upgrader){}
    virtual ~upgrade_visitor() {}
  public:
    upgrade_visitor(const upgrade_visitor& a_from)
    : dir::visitor(a_from)
    ,m_upgrader(a_from.m_upgrader)
    {}
    upgrade_visitor& operator=(const upgrade_visitor&){return *this;}
  private:
    upgrader& m_upgrader;
  };

public:
  upgrader(std::ostream& a_out,bool a_verbose,const std::string& a_upfile,const std::string& aFilter)
  :m_out(a_out)
  ,m_verbose(a_verbose)
  ,m_filter(aFilter)
  {
    if(m_verbose) {
      m_out << "upgrader::upgrader :"
           << " upgrade file is " << inlib::sout(a_upfile) 
           << std::endl;
    }
    std::string _a_upfile;
    file_name(a_upfile,_a_upfile);
    if(!inlib::file::read(_a_upfile,m_orders)) {
      m_out << "upgrader::upgrader :"
           << " can't read upgrade file." 
           << std::endl;
    }
  
    // include files :
    bool hasIncs = true;
    while(hasIncs) {
      hasIncs = false;
      std::vector<std::string> orders;
      unsigned int ordern = m_orders.size();
      for(unsigned int index=0;index<ordern;index++) {
        std::vector<std::string> wrds = words(m_orders[index],"\\n");
        if( (wrds.size()==2) && (wrds[0]=="include")) {
          const std::string& file = wrds[1];
          if(m_verbose) {
            m_out << "upgrader::upgrade_file :"
                 << " include " << inlib::sout(file) 
                 << std::endl;
          }
          std::vector<std::string> incs;
          std::string _file;
          file_name(file,_file);
          if(!inlib::file::read(_file,incs)) {
            m_out << "upgrader::upgrader :"
                 << " can't read include upgrade file " 
                 << inlib::sout(file) << "."
                 << std::endl;
            m_orders.clear();
            return;
          }
          unsigned int incn = incs.size();
          for(unsigned int inci=0;inci<incn;inci++) {
            hasIncs = true;
            orders.push_back(incs[inci]);
          }
        } else {
          orders.push_back(m_orders[index]);
        }
      }
      m_orders = orders;
    }
  }

  virtual ~upgrader(){}

public:
  upgrader(const upgrader& a_from)
  :m_out(a_from.m_out)
  ,m_verbose(a_from.m_verbose)
  ,m_orders(a_from.m_orders)
  ,m_filter(a_from.m_filter)
  {}
  upgrader& operator=(const upgrader& a_from){
    m_verbose = a_from.m_verbose;  
    m_orders = a_from.m_orders;
    m_filter = a_from.m_filter;
    return *this;
  }
public:  
  bool verbose() const {return m_verbose;}

  bool upgrade(const std::string& a_string) {
    if(!m_orders.size()) return true; //Nothing to do.
    bool value;
    if(!dir::is_a(a_string,value)) return false;
    if(value) return upgrade_dir(a_string);
    else return upgrade_file(a_string);
  }

  bool upgrade_file(const std::string& a_file) {
    if(m_verbose) {
      m_out << "upgrader::upgrade_file :"
          << " upgrade file " << inlib::sout(a_file) << "..."
          << std::endl;
    }
    if(m_filter.size()) {
      if(!match(a_file,m_filter)) return true;
    }
    unsigned int ordern = m_orders.size();
    for(unsigned int index=0;index<ordern;index++) {
      std::vector<std::string> wrds =
        words(m_orders[index],"\\n",true); //true = take empty.
      if(m_orders[index].size()<=0) {
      } else if( (m_orders[index].size()>=1) && (m_orders[index][0]=='#') ) {
  
      } else if( (wrds.size()==3) && (wrds[0]=="replace")) {
        if(m_verbose) {
          m_out << "upgrader::upgrade_file :"
              << " replace " << inlib::sout(wrds[1]) 
              << " by " << inlib::sout(wrds[2]) 
              << std::endl;
        }
        std::vector<std::string> changes;
        if(!replace(a_file,wrds[1],wrds[2],changes)) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }
        unsigned int changen = changes.size();
        for(unsigned int count=0;count<changen;count+=2) {
          m_out << ">>>>>>>>>>>>> In file " << inlib::sout(a_file) 
              << ", line changed : " << std::endl;
          m_out << changes[count] << std::endl;
          m_out << changes[count+1] << std::endl;
        }
  
      } else if( (wrds.size()==4) && (wrds[0]=="replace_if")) {
        if(m_verbose) {
          m_out << "upgrader::upgrade_file :"
              << " if " << inlib::sout(wrds[1]) 
              << " replace " << inlib::sout(wrds[2]) 
              << " by " << inlib::sout(wrds[3]) 
              << std::endl;
        }
        std::vector<std::string> changes;
        if(!replace_if(a_file,wrds[1],wrds[2],wrds[3],changes)) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }
        unsigned int changen = changes.size();
        for(unsigned int count=0;count<changen;count+=2) {
          m_out << ">>>>>>>>>>>>> In file " << inlib::sout(a_file) 
              << ", line changed : " << std::endl;
          m_out << changes[count] << std::endl;
          m_out << changes[count+1] << std::endl;
        }

      } else if( (wrds.size()==2) && (wrds[0]=="remove_line")) {
        if(m_verbose) {
          m_out << "upgrader::upgrade_file :"
              << " remove_line " << inlib::sout(wrds[1]) 
              << std::endl;
        }
        if(!remove_lines(a_file,wrds[1])) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }

      } else if( (wrds.size()==2) && (wrds[0]=="remove_if")) {
        if(m_verbose) {
          m_out << "upgrader::upgrade_file :"
              << " remove_if " << inlib::sout(wrds[1]) 
              << std::endl;
        }
        if(!remove_if(a_file,wrds[1])) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }

      } else if( (wrds.size()==3) && (wrds[0]=="if_rm_eol")) {
        if(m_verbose) {
          m_out << "upgrader::upgrade_file :"
              << " if_rm_eol " << inlib::sout(wrds[1]) 
              << std::endl;
        }
        std::vector<std::string> changes;
        if(!if_rm_eol(a_file,wrds[1],wrds[2],changes)) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }
        unsigned int changen = changes.size();
        for(unsigned int count=0;count<changen;count+=2) {
          m_out << ">>>>>>>>>>>>> In file " << inlib::sout(a_file) 
              << ", line changed : " << std::endl;
          m_out << changes[count] << std::endl;
          m_out << changes[count+1] << std::endl;
        }

      } else if( (wrds.size()==3) && (wrds[0]=="warn")) {
        std::vector<std::string> found;
        if(!file::found(a_file,wrds[1],found)) {
          m_out << "upgrader::upgrade_file :"
              << " upgrade of file " << inlib::sout(a_file) << " fails."
              << std::endl;
          return false;
        }
        unsigned int foundn = found.size();
        for(unsigned int count=0;count<foundn;count++) {
          m_out << ">>>>>>>>>>>>> In file " << inlib::sout(a_file) 
              << ", have to upgrade by hand line :" 
              << std::endl;
          m_out << found[count] << std::endl;
          m_out << "Action being :" << std::endl;
          m_out << wrds[2] << std::endl;
        }
      } else {
        m_out << "upgrader::upgrade_file :"
            << " bad formed or unknown request " << inlib::sout(m_orders[index])
            << std::endl;
      }
    }
    return true;
  }
  
  bool upgrade_dir(const std::string& aPath) {
    if(!m_orders.size()) return true; //Nothing to do.
    if(m_verbose) {
      m_out << "upgrader::upgrade_dir :"
          << " upgrade directory " << inlib::sout(aPath) << "..."
          << std::endl;
    }
    dir::tree tree(m_out);
    tree.set_path(aPath);
    if(!tree.build()) {
      m_out << "upgrader::upgrade_dir :"
            << "Can't get files of " << inlib::sout(aPath) << std::endl;
      return false;
    }
    upgrade_visitor visitor(*this);
    return tree.visit(visitor);
  }
private:
  static bool replace(const std::string& a_file,const std::string& a_old,const std::string& a_new,std::vector<std::string>& a_changes){
    a_changes.clear();
    std::vector<std::string> text;
    if(!file::read(a_file,text)) return false;
    // Replace :
    bool touched = false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      std::string old = *it;
      if(inlib::replace(*it,a_old,a_new)) {
        a_changes.push_back(old);
        a_changes.push_back(*it);
        touched = true;
      }
    }}
    if(!touched) return true;
    // Create temporary file :
    //NOTE : have a tmpname in current directory so that the below 
    //       rename works. (Else we should do a move).
    std::string tmp_name;
    if(!tmpname(".","inlib_","",tmp_name)) return false;
    FILE* file = ::fopen(tmp_name.c_str(),"wb");
    if(!file) return false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      if(::fprintf(file,"%s\n",(*it).c_str())<0) {
        ::fclose(file);
        ::remove(tmp_name.c_str());
        return false;
      }
    }}
    ::fclose(file);
    if(::remove(a_file.c_str())!=0) return false;
    //NOTE : tmp_name, a_file must not be a path !
    //       Darwin is ok with a path but not Linux !
    //       For example : 
    //         ::rename("/tmp/tmp01"."x");
    //       return -1 on Linux.
    //       To do the upper then someone must use move. 
    //       But there is no move in the standard lib C !
    if(::rename(tmp_name.c_str(),a_file.c_str())!=0) return false;
    return true;
  }

  static bool replace_if(const std::string& a_file,const std::string& a_if,const std::string& a_old,const std::string& a_new,std::vector<std::string>& a_changes){
    a_changes.clear();
    std::vector<std::string> text;
    if(!file::read(a_file,text)) return false;
    // Replace :
    bool touched = false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      std::string old = *it;
      if(old.find(a_if)!=std::string::npos) {
        if(inlib::replace(*it,a_old,a_new)) {
          a_changes.push_back(old);
          a_changes.push_back(*it);
          touched = true;
        }
      }
    }}
    if(!touched) return true;
    // Create temporary file :
    //NOTE : have a tmpname in current directory so that the below 
    //       rename works. (Else we should do a move).
    std::string tmp_name;
    if(!tmpname(".","inlib_","",tmp_name)) return false;
    FILE* file = ::fopen(tmp_name.c_str(),"wb");
    if(!file) return false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      if(::fprintf(file,"%s\n",(*it).c_str())<0) {
        ::fclose(file);
        ::remove(tmp_name.c_str());
        return false;
      }
    }}
    ::fclose(file);
    if(::remove(a_file.c_str())!=0) return false;
    if(::rename(tmp_name.c_str(),a_file.c_str())!=0) return false;
    return true;
  }
  
  static bool if_rm_eol(const std::string& a_file,const std::string& a_if,const std::string& a_rm,std::vector<std::string>& a_changes){
    a_changes.clear();
    std::vector<std::string> text;
    if(!file::read(a_file,text)) return false;
    bool touched = false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      std::string old = *it;
      std::string& line = (*it);
      if(line.find(a_if)!=std::string::npos) {
        std::string::size_type pos = line.find(a_rm);
        if(pos!=std::string::npos) {
          line = line.substr(0,pos);
          a_changes.push_back(old);
          a_changes.push_back(line);
          touched = true;
        }
      }
    }}
    if(!touched) return true;
    // Create temporary file :
    //NOTE : have a tmpname in current directory so that the below 
    //       rename works. (Else we should do a move).
    std::string tmp_name;
    if(!tmpname(".","inlib_","",tmp_name)) return false;
    FILE* file = ::fopen(tmp_name.c_str(),"wb");
    if(!file) return false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      if(::fprintf(file,"%s\n",(*it).c_str())<0) {
        ::fclose(file);
        ::remove(tmp_name.c_str());
        return false;
      }
    }}
    ::fclose(file);
    if(::remove(a_file.c_str())!=0) return false;
    if(::rename(tmp_name.c_str(),a_file.c_str())!=0) return false;
    return true;
  }
  
  static bool remove_lines(const std::string& a_file,const std::string& a_to_remove){
    std::vector<std::string> text;
    if(!file::read(a_file,text)) return false;
    bool touched = false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();) {
      std::string line = *it;
      if(line==a_to_remove) {
        it = text.erase(it); 
        touched = true;
      } else {
        it++;
      }
    }}
    if(!touched) return true;
    // Create temporary file :
    //NOTE : have a tmpname in current directory so that the below 
    //       rename works. (Else we should do a move).
    std::string tmp_name;
    if(!tmpname(".","inlib_","",tmp_name)) return false;
    FILE* file = ::fopen(tmp_name.c_str(),"wb");
    if(!file) return false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      if(::fprintf(file,"%s\n",(*it).c_str())<0) {
        ::fclose(file);
        ::remove(tmp_name.c_str());
        return false;
      }
    }}
    ::fclose(file);
    if(::remove(a_file.c_str())!=0) return false;
    if(::rename(tmp_name.c_str(),a_file.c_str())!=0) return false;
    return true;
  }
  
  static bool remove_if(const std::string& a_file,const std::string& a_if){
    std::vector<std::string> text;
    if(!file::read(a_file,text)) return false;
    bool touched = false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();) {
      std::string line = *it;
      if(line.find(a_if)!=std::string::npos) {
        it = text.erase(it); 
        touched = true;
      } else {
        it++;
      }
    }}
    if(!touched) return true;
    // Create temporary file :
    //NOTE : have a tmpname in current directory so that the below 
    //       rename works. (Else we should do a move).
    std::string tmp_name;
    if(!tmpname(".","inlib_","",tmp_name)) return false;
    FILE* file = ::fopen(tmp_name.c_str(),"wb");
    if(!file) return false;
   {std::vector<std::string>::iterator it;
    for(it=text.begin();it!=text.end();++it) {
      if(::fprintf(file,"%s\n",(*it).c_str())<0) {
        ::fclose(file);
        ::remove(tmp_name.c_str());
        return false;
      }
    }}
    ::fclose(file);
    if(::remove(a_file.c_str())!=0) return false;
    if(::rename(tmp_name.c_str(),a_file.c_str())!=0) return false;
    return true;
  }
  
private:
  std::ostream& m_out;
  bool m_verbose;
  std::vector<std::string> m_orders;
  std::string m_filter;
};

}

#endif