filerevisions.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2019  Erik Haenel et al.
 
    This program 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.
 
    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#include "filerevisions.hpp"
#include "dtl/dtl.hpp"
#include <wx/zipstrm.h>
#include <wx/txtstrm.h>
#include <wx/wfstream.h>
#include <memory>
#include <fstream>
#include <sstream>
#include <wx/encconv.h>
 
#define COMPRESSIONLEVEL 6
 
#include "../kernel/core/utils/stringtools.hpp"
 
FileRevisions::FileRevisions(const wxString& revisionPath) : m_revisionPath(revisionPath)
{
    if (!m_revisionPath.Exists())
        wxFileName::Mkdir(m_revisionPath.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
}
 
 
std::vector<wxString> FileRevisions::vectorize(wxString fileContent)
{
    std::vector<wxString> vVectorizedFile;
 
    // As long as there are contents left in the
    // current file
    while (fileContent.length())
    {
        // Push the current line to the vector
        vVectorizedFile.push_back(fileContent.substr(0, fileContent.find('\n')));
 
        // Erase the current line from the file
        if (fileContent.find('\n') != std::string::npos)
            fileContent.erase(0, fileContent.find('\n')+1);
        else
            break;
    }
 
    // Return the vectorized file
    return vVectorizedFile;
}
 
 
 
wxString FileRevisions::convertLineEndings(const wxString& content)
{
    wxString target = content;
 
    while (target.find("\r\n") != std::string::npos)
        target.erase(target.find("\r\n"), 1);
 
    return target;
}
 
 
wxString FileRevisions::readRevision(const wxString& revString)
{
    wxFFileInputStream in(m_revisionPath.GetFullPath());
    wxZipInputStream zip(in);
    wxTextInputStream txt(zip, " \t", wxConvUTF8); // Convert from UTF-8 to Unicode on-the-fly
 
    std::unique_ptr<wxZipEntry> entry;
 
    // Search for the entry with the correct name
    // in the file
    while (entry.reset(zip.GetNextEntry()), entry.get() != nullptr)
    {
        // Found it?
        if (entry->GetName() == revString)
        {
            wxString revision;
 
            // Read the whole entry and append windows line endings. The
            // necessary conversion from UTF-8 is done by the text input
            // stream on-the-fly
            while (!zip.Eof())
                revision += wxString(txt.ReadLine()) + "\r\n";
 
            // Remove the last line's endings
            revision.erase(revision.length()-2);
 
            // If the ZIP comment equals "DIFF", we need to merge
            // the changes in this revision into the current
            // revision root
            if (entry->GetComment() == "DIFF")
                revision = createMerge(revision);
 
            return revision;
        }
    }
 
    return "";
}
 
 
wxString FileRevisions::getLastContentModification(const wxString& revString)
{
    // Get the revision list
    wxArrayString revisionList = getRevisionList();
    bool revFound = false;
 
    // Go reversely through the revision list and try to find
    // the revision tag, where the file was modified lastly
    for (int i = revisionList.size()-1; i >= 0; i--)
    {
        // Found the user selected revision?
        if (!revFound && revisionList[i].substr(0, revisionList[i].find('\t')) == revString)
            revFound = true;
 
        // Does the comment section contain one of the ignored
        // tags?
        if (revFound
            && revisionList[i].find("\tMOVE:") == std::string::npos
            && revisionList[i].find("\tRENAME:") == std::string::npos
            && revisionList[i].find("\tTAG:") == std::string::npos)
            return revisionList[i].substr(0, revisionList[i].find('\t'));
    }
 
    return revString;
}
 
 
wxString FileRevisions::getLastRevisionRoot(const wxString& revString)
{
    // Get the revision list
    wxArrayString revisionList = getRevisionList();
    bool revFound = false;
 
    // Go reversely through the revision list and try to find
    // the revision tag, where the file was modified lastly
    for (int i = revisionList.size()-1; i >= 0; i--)
    {
        // Found the user selected revision?
        if (!revFound && revisionList[i].substr(0, revisionList[i].find('\t')) == revString)
            revFound = true;
 
        // Is there an empty comment or the initial revision?
        if (revFound
            && (revisionList[i].find("\tInitial revision") != std::string::npos
                || revisionList[i].substr(revisionList[i].length()-1) == "\t"))
            return revisionList[i].substr(0, revisionList[i].find('\t'));
    }
 
    return revString;
}
 
 
wxString FileRevisions::diff(const wxString& revision1, const wxString& revisionID1, const wxString& revision2, const wxString& revisionID2)
{
    // Vectorize the revision root and the current file
    std::vector<wxString> vVectorizedRoot = vectorize(convertLineEndings(revision1));
    std::vector<wxString> vVectorizedFile = vectorize(convertLineEndings(revision2));
 
    // Calculate the differences between both files
    dtl::Diff<wxString> diffFile(vVectorizedRoot, vVectorizedFile);
    diffFile.compose();
 
    // Convert the differences into unified form
    diffFile.composeUnifiedHunks();
 
    // Print the differences to a string stream
    std::ostringstream uniDiff;
 
    // Get revision identifier
    if (revisionID1.length() && revisionID2.length())
        uniDiff << "--- " << revisionID1 << "\n+++ " << revisionID2 << "\n";
 
    diffFile.printUnifiedFormat(uniDiff);
 
    // Return the contents of the stream
    return uniDiff.str();
}
 
 
wxString FileRevisions::createDiff(const wxString& revisionContent)
{
    // Find the revision root
    wxString revisionRoot = getRevision(getLastRevisionRoot(getCurrentRevision()));
 
    // Calculate the differences of both files
    return diff(revisionRoot, getLastRevisionRoot(getCurrentRevision()), revisionContent, "rev"+toString(getRevisionCount()));
}
 
 
wxString FileRevisions::createMerge(const wxString& diffFile)
{
    // Vectorizes the passed diff file and the current revision root
    std::vector<wxString> vVectorizedDiff = vectorize(convertLineEndings(diffFile));
    std::vector<wxString> vVectorizedRoot = vectorize(convertLineEndings(getRevision(vVectorizedDiff.front().substr(4))));
 
    int nCurrentInputLine = 0;
 
    // Go through the lines of the diff file. Ignore the first
    // two, because they only contain the revision identifiers.
    for (size_t i = 2; i < vVectorizedDiff.size(); i++)
    {
        // The start of a change section. Extract the target input
        // line in the current revision (the second number set starting
        // with a "+")
        if (vVectorizedDiff[i].substr(0, 4) == "@@ -")
        {
            nCurrentInputLine = atoi(vVectorizedDiff[i].substr(vVectorizedDiff[i].find('+')+1, vVectorizedDiff[i].find(',', vVectorizedDiff[i].find('+') - vVectorizedDiff[i].find('+')-1)).c_str())-1;
            continue;
        }
 
        // A deletion. This requires that we decrement the current
        // input line
        if (vVectorizedDiff[i][0] == '-')
        {
            vVectorizedRoot.erase(vVectorizedRoot.begin()+nCurrentInputLine);
            nCurrentInputLine--;
        }
 
        // An addition
        if (vVectorizedDiff[i][0] == '+')
            vVectorizedRoot.insert(vVectorizedRoot.begin()+nCurrentInputLine, vVectorizedDiff[i].substr(1));
 
        // Always increment the current input line
        nCurrentInputLine++;
    }
 
    wxString mergedFile;
 
    // Merge the vectorized file into a single-string file
    for (size_t i = 0; i < vVectorizedRoot.size(); i++)
        mergedFile += vVectorizedRoot[i] + "\r\n";
 
    // Return the merged file with exception of the trailing
    // line break characters
    return mergedFile.substr(0, mergedFile.length()-2);
}
 
 
wxString FileRevisions::readExternalFile(const wxString& filePath)
{
    std::ifstream file_in;
    wxString sFileContents;
    std::string sLine;
    wxMBConvUTF8 conv;
 
    file_in.open(filePath.ToStdString().c_str());
 
    while (file_in.good() && !file_in.eof())
    {
        std::getline(file_in, sLine);
        sFileContents += sLine + "\r\n";
    }
 
    sFileContents.erase(sFileContents.length()-2);
 
    return sFileContents;
}
 
 
size_t FileRevisions::createNewRevision(const wxString& revContent, const wxString& comment)
{
    size_t revisionNo = getRevisionCount();
 
    std::unique_ptr<wxFFileInputStream> in(new wxFFileInputStream(m_revisionPath.GetFullPath()));
    wxTempFileOutputStream out(m_revisionPath.GetFullPath());
 
    wxZipInputStream inzip(*in);
    wxZipOutputStream outzip(out, COMPRESSIONLEVEL);
    wxTextOutputStream txt(outzip);
 
    std::unique_ptr<wxZipEntry> entry;
 
    outzip.CopyArchiveMetaData(inzip);
 
    // Copy all available entries to the new file
    while (entry.reset(inzip.GetNextEntry()), entry.get() != nullptr)
    {
        outzip.CopyEntry(entry.release(), inzip);
    }
 
    // Create the new revision
    wxZipEntry* currentRev = new wxZipEntry("rev" + toString(revisionNo));
    currentRev->SetComment(comment);
 
    outzip.PutNextEntry(currentRev);
    txt << revContent;
    outzip.CloseEntry();
 
    // Close the temporary file and commit it,
    // so that it may override the previous file
    // safely.
    in.reset();
    outzip.Close();
    out.Commit();
 
    return revisionNo;
}
 
 
size_t FileRevisions::createNewTag(const wxString& revString, const wxString& comment)
{
    wxString revision = "TAG FOR " + revString;
    size_t revisionNo = getRevisionCount();
    wxZipEntry* taggedRevision = new wxZipEntry("tag" + revString.substr(3) + "-rev" + toString(revisionNo));
    taggedRevision->SetComment("TAG: " + comment);
 
    std::unique_ptr<wxFFileInputStream> in(new wxFFileInputStream(m_revisionPath.GetFullPath()));
    wxTempFileOutputStream out(m_revisionPath.GetFullPath());
 
    wxZipInputStream inzip(*in);
    wxZipOutputStream outzip(out, COMPRESSIONLEVEL);
    wxTextOutputStream txt(outzip);
 
    std::unique_ptr<wxZipEntry> entry;
 
    outzip.CopyArchiveMetaData(inzip);
 
    // Copy the contents to the new file
    while (entry.reset(inzip.GetNextEntry()), entry.get() != nullptr)
    {
        // is this the selected revision?
        if (entry->GetName() == revString)
        {
            outzip.CopyEntry(entry.release(), inzip);
 
            // Append the tag directly after the
            // selected revision
            outzip.PutNextEntry(taggedRevision);
            txt << revision;
            outzip.CloseEntry();
        }
        else
            outzip.CopyEntry(entry.release(), inzip);
    }
 
    // Close the temporary file and commit it,
    // so that it may override the previous file
    // safely.
    in.reset();
    outzip.Close();
    out.Commit();
 
    return revisionNo;
}
 
 
void FileRevisions::fileMove(const wxString& newRevPath, const wxString& comment)
{
    wxString revContent = "FILEMOVE OPERATION ON " + getCurrentRevision();
    createNewRevision(revContent, comment);
 
    wxFileName newPath(newRevPath);
 
    if (!newPath.DirExists())
        wxFileName::Mkdir(newPath.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
 
    wxRenameFile(m_revisionPath.GetFullPath(), newRevPath);
    m_revisionPath.Assign(newRevPath);
}
 
 
size_t FileRevisions::getMaxDiffFileSize(size_t nFileSize)
{
    const size_t MINFILESIZE = 1024;
    double dOffset = nFileSize > MINFILESIZE ? ((double)MINFILESIZE / (double)nFileSize) : 0.5;
    size_t nTargetFileSize = ((1.0 - dOffset) * 0.8 * exp(-(double)getRevisionCount() / 40.0) + dOffset) * nFileSize;
    return nTargetFileSize > (MINFILESIZE / 2) ? nTargetFileSize : (MINFILESIZE / 2);
}
 
 
size_t FileRevisions::getRevisionCount()
{
    if (!m_revisionPath.Exists())
        return 0;
 
    wxFFileInputStream in(m_revisionPath.GetFullPath());
    wxZipInputStream zip(in);
 
    return zip.GetTotalEntries();
}
 
 
wxArrayString FileRevisions::getRevisionList()
{
    wxArrayString stringArray;
 
    if (m_revisionPath.Exists())
    {
        wxFFileInputStream in(m_revisionPath.GetFullPath());
        wxZipInputStream zip(in);
 
        std::unique_ptr<wxZipEntry> entry;
 
        // Get the names, the time and the comments for each entry
        // in the ZIP file
        while (entry.reset(zip.GetNextEntry()), entry.get() != nullptr)
        {
            stringArray.Add(entry->GetName() + "\t" + entry->GetDateTime().FormatISOCombined(' ') + "\t" + entry->GetComment());
        }
    }
 
    return stringArray;
}
 
 
wxString FileRevisions::getCurrentRevision()
{
    wxArrayString revList = getRevisionList();
 
    for (int i = revList.size()-1; i >= 0; i--)
    {
        if (revList[i].substr(0, 3) == "rev")
            return revList[i].substr(0, revList[i].find('\t'));
    }
 
    return "";
}
 
 
wxString FileRevisions::getRevision(size_t nRevision)
{
    if (!m_revisionPath.Exists())
        return "";
 
    return getRevision("rev" + toString(nRevision));
}
 
 
wxString FileRevisions::getRevision(wxString revString)
{
    if (!m_revisionPath.Exists())
        return "";
 
    if (revString.substr(0, 3) == "tag")
    {
        revString.replace(0, 3, "rev");
        revString.erase(revString.find('-'));
    }
 
    revString = getLastContentModification(revString);
 
    return readRevision(revString);
}
 
 
wxString FileRevisions::compareRevisions(const wxString& rev1, const wxString& rev2)
{
    return diff(getRevision(rev1), rev1, getRevision(rev2), rev2);
}
 
 
void FileRevisions::restoreRevision(size_t nRevision, const wxString& targetFile)
{
    wxString revision = getRevision(nRevision);
 
    wxFile restoredFile;
    restoredFile.Open(targetFile, wxFile::write);
    restoredFile.Write(revision);
 
    createNewRevision(convertLineEndings(revision), "RESTORE: rev" + toString(nRevision));
}
 
 
void FileRevisions::restoreRevision(const wxString& revString, const wxString& targetFile)
{
    wxString revision = getRevision(revString);
 
    wxFile restoredFile;
    restoredFile.Open(targetFile, wxFile::write);
    restoredFile.Write(revision);
 
    createNewRevision(convertLineEndings(revision), "RESTORE: " + revString);
}
 
 
size_t FileRevisions::tagRevision(size_t nRevision, const wxString& tagComment)
{
    // Will probably fail, because the selected revision is not
    // stored as "revXYZ" but as "tagABC-revXYZ"
    return createNewTag("rev" + toString(nRevision), tagComment);
}
 
 
size_t FileRevisions::tagRevision(const wxString& revString, const wxString& tagComment)
{
    return createNewTag(revString, tagComment);
}
 
 
size_t FileRevisions::addRevision(const wxString& revisionContent)
{
    wxString revContent = convertLineEndings(revisionContent);
 
    if (!m_revisionPath.Exists())
    {
        wxFFileOutputStream out(m_revisionPath.GetFullPath());
        wxZipOutputStream zip(out, COMPRESSIONLEVEL);
        wxTextOutputStream txt(zip);
 
        wxZipEntry* rev0 = new wxZipEntry("rev0");
        rev0->SetComment("Initial revision");
 
        zip.PutNextEntry(rev0);
        txt << revContent;
        zip.CloseEntry();
 
        return 0;
    }
    else
    {
        // Only add a new revision if the contents differ
        if (revisionContent == getRevision(getCurrentRevision()))
            return -1;
 
        wxString diffFile = createDiff(revisionContent);
 
        if (diffFile.length() < getMaxDiffFileSize(revContent.length()))
            return createNewRevision(diffFile, "DIFF");
        else
            return createNewRevision(revContent, "");
    }
}
 
 
size_t FileRevisions::addExternalRevision(const wxString& filePath)
{
    wxString revContent = readExternalFile(filePath);
 
    if (!revContent.length())
        revContent = "Other error";
 
    // Only add the external revision, if it actually
    // modified the file
    wxString currRev = getRevision(getCurrentRevision());
    if (currRev == revContent)
        return -1;
 
    // Ensure that the diff is not actually empty
    if (!diff(currRev, "", revContent, "").length())
        return -1;
 
    return createNewRevision(convertLineEndings(revContent), "External modification");
}
 
 
void FileRevisions::undoRevision()
{
    if (m_revisionPath.Exists())
    {
        size_t revisionNo = getRevisionCount();
 
        if (revisionNo > 1)
        {
            std::unique_ptr<wxFFileInputStream> in(new wxFFileInputStream(m_revisionPath.GetFullPath()));
            wxTempFileOutputStream out(m_revisionPath.GetFullPath());
 
            wxZipInputStream inzip(*in);
            wxZipOutputStream outzip(out, COMPRESSIONLEVEL);
            wxTextOutputStream txt(outzip);
 
            std::unique_ptr<wxZipEntry> entry;
 
            outzip.CopyArchiveMetaData(inzip);
 
            while (entry.reset(inzip.GetNextEntry()), entry.get() != nullptr)
            {
                if (entry->GetName() != "rev" + wxString(toString(revisionNo-1)))
                    outzip.CopyEntry(entry.release(), inzip);
            }
 
            in.reset();
            outzip.Close();
            out.Commit();
        }
        else
            wxRemoveFile(m_revisionPath.GetFullPath());
    }
}
 
 
void FileRevisions::renameFile(const wxString& oldName, const wxString& newName, const wxString& newRevPath)
{
    fileMove(newRevPath, "RENAME: " + oldName + " -> " + newName);
}
 
 
void FileRevisions::moveFile(const wxString& oldPath, const wxString& newPath, const wxString& newRevPath)
{
    fileMove(newRevPath, "MOVE: " + oldPath + " -> " + newPath);
}