vcsdiff.cpp

Go to the documentation of this file.

/***************************************************************************
 *   This file is part of KDevelop                                         *
 *   Copyright 2007 Andreas Pakulat <[email protected]>                     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 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 Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
 ***************************************************************************/
 
#include "vcsdiff.h"
 
#include "debug.h"
 
#include <QString>
#include <QUrl>
#include <QSharedData>
#include <QRegularExpression>
#include <QtGlobal>
 
namespace KDevelop
{
 
 
/* A class representing a diff hunk (a collection of localized changes) */
class DiffHunk {
public:
    /* Metadata for the hunk */
    uint srcStart      
       , srcCount      
       , tgtStart      
       , tgtCount      
       , headingLineIdx  
       ;
    QString srcFile    
          , tgtFile    
          , heading    
          ;
    QStringList lines; 
    uint lastLineIdx() const { return headingLineIdx+lines.size(); }
 
    bool containsDiffLine( uint lineIdx ) const {return headingLineIdx <= lineIdx && lineIdx <= lastLineIdx();}
 
    int diffLineToHunkLine(uint diffLineIdx) const {
        return diffLineIdx-(headingLineIdx+1);
    }
 
    static QString formatHeader(uint oldStart, uint oldCount, uint newStart, uint newCount, QString head);
 
    bool operator<( const DiffHunk& b ) const {return lastLineIdx() < b.headingLineIdx;}
    bool operator<( uint line ) const  {return lastLineIdx() < line;}
    bool operator<=( const KDevelop::DiffHunk& b ) const {return lastLineIdx() <= b.headingLineIdx;}
    bool operator<=( uint line ) const {return lastLineIdx() <= line;}
    bool operator>( const KDevelop::DiffHunk& b ) const {return headingLineIdx > b.lastLineIdx();}
    bool operator>( uint line ) const {return headingLineIdx > line;}
    bool operator>= ( const KDevelop::DiffHunk& b ){return headingLineIdx >= b.lastLineIdx();}
    bool operator>=( uint line ) const {return headingLineIdx >= line;}
};
 
/* RegExp matching a hunk header line */
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, HUNK_HEADER_RE, (QLatin1String("^@@ -([0-9,]+) \\+([0-9,]+) @@(.*)")))
// static const auto HUNK_HEADER_RE = QRegularExpression(QStringLiteral("^@@ -([0-9,]+) \\+([0-9,]+) @@(.*)"));
 
/* RegExp matching a meta line containing a source of target filename */
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, DIFF_FILENAME_RE, (QLatin1String("^[-+]{3} [ab]/(.*)")))
 
/* RegExp matching a meta line (hunk header, filename, other info) */
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, META_LINE_RE, (QLatin1String("(^[-+]{3} )|^[^-+ ]")))
 
/* RegExps matching conflict delimiting lines */
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, CONFLICT_START_RE, (QLatin1String("^<<<<<<<")))
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, CONFLICT_MID_RE, (QLatin1String("^=======")))
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, CONFLICT_END_RE, (QLatin1String("^>>>>>>>")))
Q_GLOBAL_STATIC_WITH_ARGS(const QRegularExpression, CONFLICT_RE, (QLatin1String("(^>>>>>>>)|(^=======)|(^<<<<<<<)")))
 
QString formatRange(uint start, uint count) {
    if (count == 1) return QString().setNum(start);
    return QString().setNum(start)+QLatin1Char(',')+QString().setNum(count);
}
std::pair<uint, uint> parseRange(const QString& range) {
    int commaPos = range.indexOf(QLatin1Char(','));
    if (commaPos > -1) {
        return {range.midRef(0,commaPos).toInt(), range.midRef(commaPos+1).toInt()};
    }
    return {range.toInt(), 1};
}
 
/* Creates a hunk header line (starting with @@)
 *
 * Note: The line will not end with a newline */
QString DiffHunk::formatHeader(uint oldStart, uint oldCount, uint newStart, uint newCount, QString head) {
    return QLatin1String("@@ -")
         + formatRange(oldStart, oldCount)
         + QLatin1String(" +")
         + formatRange(newStart, newCount)
         + QLatin1String(" @@")
         + head;
}
 
QList<KDevelop::DiffHunk *> parseHunks(VcsDiff& diff)
{
    QList<KDevelop::DiffHunk*> ret;
    int lineNo = -1;
    QString curSrcFileName, curTgtFileName;
    QStringListIterator lines(diff.diff().split(QLatin1Char('\n')));
    while( lines.hasNext() ) {
        lineNo++;
        auto curln = lines.next();
        auto m = DIFF_FILENAME_RE->match(curln);
        if (m.hasMatch()) {
            if (curln.startsWith(QLatin1Char('-')))
                curSrcFileName = m.captured(1);
            else if (curln.startsWith(QLatin1Char('+')))
                curTgtFileName = m.captured(1);
            continue;
        }
        m = HUNK_HEADER_RE->match(curln);
        if (! m.hasMatch() ) continue;
        auto [oldStart, oldCount] = parseRange(m.captured(1));
        auto [newStart, newCount] = parseRange(m.captured(2));
        auto heading = m.captured(3);
        uint firstLineIdx = lineNo;
        QStringList hunkLines;
        while( lines.hasNext() && (
             CONFLICT_START_RE->match(lines.peekNext()).hasMatch() ||
           ! META_LINE_RE->match(lines.peekNext()).hasMatch()
        )) {
            // Consume the conflict
            if (CONFLICT_START_RE->match(lines.peekNext()).hasMatch()) {
                lineNo ++;
                hunkLines << lines.next();
                while( lines.hasNext() && ! CONFLICT_END_RE->match(lines.peekNext()).hasMatch()) {
                    lineNo++;
                    hunkLines << lines.next();
                }
                if (! CONFLICT_END_RE->match(lines.peekNext()).hasMatch()) {
                    qCWarning(VCS) << "Invalid diff format, end of file reached before conflict finished";
                    qCDebug(VCS) << diff.diff();
                    break;
                }
            }
            lineNo ++;
            hunkLines << lines.next();
        }
 
        // The number of filenames present in the diff should match the number
        // of hunks
        ret << new DiffHunk{
            oldStart
          , oldCount
          , newStart
          , newCount
          , firstLineIdx
          , curSrcFileName
          , curTgtFileName
          , heading
          , hunkLines
        };
    }
 
    // If the diff ends with a newline, for the last hunk, when splitting into lines above
    // we will always get an empty string at the end, which we now remove
    if (diff.diff().endsWith(QLatin1Char('\n'))) {
        if (ret.size() > 0 && ret.back()->lines.size() > 0) {
            ret.back()->lines.pop_back();
        } else {
            qCWarning(VCS) << "Failed to parse a diff, produced no hunks";
            qCDebug(VCS) << "Failed diff:" << diff.diff();
        }
    }
 
    return ret;
}
 
class VcsDiffPrivate : public QSharedData
{
public:
    QUrl baseDiff;
    QString diff;
    uint depth = 0;
    QList<DiffHunk*> hunks;
 
    enum Dest {
        SRC = '-',
        TGT = '+',
    };
 
    int mapDiffLine ( const uint line, const Dest dest ) const
    {
        const QLatin1Char skipChar = (dest == SRC) ? QLatin1Char(TGT) : QLatin1Char(SRC);
        for(auto h: hunks) {
            if (h->containsDiffLine(line)) {
                int hunkPos = h->diffLineToHunkLine(line);
 
                // The line refers to the heading line
                if (hunkPos < 0)
                    return -1;
 
                // Any lines in the diff hunk which come before line and come from the opposite
                // of dest should not be counted (they are not present in the dest)
                int skipCount = 0;
                for(int i=0; i<hunkPos; i++) {
                    if (h->lines.at(i).startsWith(skipChar)) skipCount++;
                }
 
                // Any lines in the diff hunk which come from the second part (src)/ first part (tgt)
                // of a conflict should not be counted either
                bool inConflict = false; // This is set so that a line inside a conflict is recognized as a valid line
                for(int i=0; i<hunkPos; i++) {
                    if (CONFLICT_START_RE->match(h->lines.at(i)).hasMatch()) {
                        skipCount++; // skip the conflict marker line
                        if (dest == TGT) {
                            while((++i)<hunkPos && !CONFLICT_MID_RE->match(h->lines.at(i)).hasMatch()) {
                                skipCount++;
                            }
                        } else {
                            inConflict = true;
                        }
                    }
                    if (CONFLICT_MID_RE->match(h->lines.at(i)).hasMatch()) {
                        skipCount++; // skip the conflict marker line
                        if (dest == SRC) {
                            while((++i)<hunkPos && !CONFLICT_END_RE->match(h->lines.at(i)).hasMatch())
                                skipCount++;
                        } else {
                            inConflict = true;
                        }
                    }
                    if (CONFLICT_END_RE->match(h->lines.at(i)).hasMatch()) {
                        skipCount++; // skip the conflict marker line
                        inConflict = false;
                    }
                }
 
                auto ln = h->lines[hunkPos];
 
                // This works around the fact that inConflict is set even if hunkPos
                // ends up hitting a conflict marker
                if (CONFLICT_RE->match(ln).hasMatch())
                    return -1;
 
                if (ln.startsWith(dest) || ln.startsWith(QLatin1Char(' ')) || ln.isEmpty() || inConflict) {
                    if (dest == SRC)
                        // The -1 accounts for the fact that srcStart is 1-based
                        // but we need to return 0-based line numbers
                        return h->srcStart-1+hunkPos-skipCount;
                    else
                        // The -1 accounts for the fact that srcStart is 1-based
                        // but we need to return 0-based line numbers
                        return h->tgtStart-1+hunkPos-skipCount;
                } else return -1;
            }
        }
        return -1;
    }
};
 
KDevelop::VcsDiff VcsDiff::subDiffHunk(const uint line, DiffDirection dir) const
{
    auto hunks = d->hunks;
    for(const auto* hunk: hunks) {
        if (hunk->containsDiffLine(line)) {
            return subDiff(hunk->headingLineIdx, hunk->lastLineIdx(), dir);
        }
    }
 
    VcsDiff emptyDiff;
    emptyDiff.setBaseDiff(d->baseDiff);
    emptyDiff.setDepth(d->depth);
    emptyDiff.setDiff(d->diff.mid(0,d->diff.indexOf(QStringLiteral("@@"))));
    return emptyDiff;
}
 
KDevelop::VcsDiff VcsDiff::subDiff(const uint startLine, const uint endLine, DiffDirection dir) const
{
    // Code adapted from cola/diffparse.py
    enum LineType {
        ADD = '+',
        DEL = '-',
        CTX = ' ',
        NO_NEWLINE = '\\'
    };
 
    VcsDiff ret;
    ret.setBaseDiff(baseDiff());
    ret.setDepth(depth());
 
 
    auto hunks = d->hunks;
    QStringList lines;
    for(const auto* hunk: hunks) {
        // Skip hunks before the first line
        if (*hunk < startLine)
            continue;
 
        // Skip hunks after the last line
        if (*hunk > endLine)
            break;
 
        std::map<LineType, int> counts = {
            {ADD, 0},
            {DEL, 0},
            {CTX, 0},
            {NO_NEWLINE, 0}
        };
        QStringList filteredLines;
 
        // Will be set if the previous line in a hunk was
        // skipped because it was not in the selected range
        bool prevSkipped = false;
 
        uint lnIdx = hunk->headingLineIdx;
 
        // Store the number of skipped lines which start the hunk
        // (i.e. lines before a first deletion (addition in case of reverse)
        // so that we can adjust the start appropriately
        int startOffset = 0;
        const auto _lines = QStringList(hunk->lines.constBegin(), hunk->lines.constEnd());
        for(const auto& line: _lines) {
            lnIdx++;
            LineType tp = line.length() > 0 ? (LineType) line[0].toLatin1() : (LineType) 0;
            QString content = line.mid(1);
 
            if (dir == Reverse) {
                if (tp == ADD) tp = DEL;
                else if (tp == DEL) tp = ADD;
            }
 
            if (lnIdx < startLine || endLine < lnIdx) {
                // skip additions (or deletions if reverse) that are not in range
                if (tp == ADD) {
                    prevSkipped=true;
                    // If we are before the range and
                    // so far we only encountered ADD (or DEL, in case of reverse) lines
                    // these will not be included in the subdiff hunk so we increase the startOffset
                    if (lnIdx < startLine && counts[CTX] == 0) startOffset++;
                    continue;
                }
                // change deletions (or additions if reverse) that are not in range into context
                if (tp == DEL) tp=CTX;
            }
 
            // If the line immediately before a "No newline" line was
            // skipped (because it was an unselected addition) skip
            // the "No newline" line as well.
            if (tp == NO_NEWLINE && prevSkipped ) {
                if (lnIdx <= endLine ) startOffset++;
                continue;
            }
 
            // Empty lines are context lines and we
            // preserve them
            if ((int)tp == 0) {
                filteredLines << content;
                tp = CTX;
            } else {
                filteredLines << QLatin1Char(tp)+content;
            }
            counts[tp]++;
            prevSkipped = false;
        }
 
        // Skip hunks which have only context lines
        if (counts[ADD] + counts[DEL] == 0)
            continue;
 
 
        // Compute the start & counts of the hunks
        uint subSrcStart, subTgtStart;
        if (dir == Reverse) {
            subSrcStart = hunk->tgtStart + startOffset;
            subTgtStart = hunk->srcStart + startOffset;
        } else {
            subSrcStart = hunk->srcStart + startOffset;
            subTgtStart = hunk->tgtStart + startOffset;
        }
        uint subSrcCount = counts[CTX] + counts[DEL];
        uint subTgtCount = counts[CTX] + counts[ADD];
 
        // Prepend lines identifying the source files
        lines << QStringLiteral("--- a/") + ((dir == Reverse) ? hunk->tgtFile : hunk->srcFile);
        lines << QStringLiteral("+++ b/") + ((dir == Reverse) ? hunk->srcFile : hunk->tgtFile);
 
        lines << DiffHunk::formatHeader(
            subSrcStart, subSrcCount,
            subTgtStart, subTgtCount,
            hunk->heading
        );
        lines += filteredLines;
    }
    if (lines.size() > 2)
        ret.setDiff(lines.join(QLatin1Char('\n'))+QLatin1Char('\n'));
    return ret;
}
 
 
const QVector<VcsDiff::FilePair> VcsDiff::fileNames() const
{
    QVector<VcsDiff::FilePair> ret;
    VcsDiff::FilePair current;
    for(auto h: d->hunks) {
        // List each pair only once
        if (h->srcFile == current.source && h->tgtFile == current.target)
            continue;
        current = {h->srcFile, h->tgtFile};
        ret.push_back(current);
    }
    return ret;
}
 
 
int VcsDiff::diffLineToSourceLine ( const uint line ) const
{
    return d->mapDiffLine(line, VcsDiffPrivate::SRC);
}
 
int VcsDiff::diffLineToTargetLine ( const uint line ) const
{
    return d->mapDiffLine(line, VcsDiffPrivate::TGT);
}
 
VcsDiff::VcsDiff()
    : d(new VcsDiffPrivate)
{
}
 
VcsDiff::~VcsDiff() = default;
 
VcsDiff::VcsDiff( const VcsDiff& rhs )
    : d(rhs.d)
{
}
 
bool VcsDiff::isEmpty() const
{
    return d->diff.isEmpty();
}
 
QString VcsDiff::diff() const
{
    return d->diff;
}
 
 
void VcsDiff::setDiff( const QString& s )
{
    d->diff = s;
    d->hunks = parseHunks(*this);
}
 
VcsDiff& VcsDiff::operator=( const VcsDiff& rhs)
{
    d = rhs.d;
    return *this;
}
 
QUrl VcsDiff::baseDiff() const
{
    return d->baseDiff;
}
 
uint VcsDiff::depth() const
{
    return d->depth;
}
 
void VcsDiff::setBaseDiff(const QUrl& url)
{
    d->baseDiff=url;
}
 
void VcsDiff::setDepth(const uint depth)
{
    d->depth = depth;
}
 
 
}