hunks/Hunk.cpp

   1 /*
   2  * This file is part of the vng project
   3  * Copyright (C) 2008 Thomas Zander <tzander@trolltech.com>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "Hunk.h"
  20
  21 #include <QDebug>
  22 #include <QRegExp>
  23
  24 class SubHunk {
  25 public:
  26     SubHunk() : start(-1), length(0), accepted(Vng::Undecided), added(0), removed(0) { }
  27     int start, length;
  28     Vng::Acceptance accepted;
  29     int added, removed;
  30     int lineNumber;
  31 };
  32
  33 class Hunk::Private {
  34 public:
  35     Private() : lineNumber(-1), ref(1), linesBefore(0), linesAfter(0)
  36     {
  37         SubHunk *sh = new SubHunk();
  38         subhunks.append(sh);
  39     }
  40
  41     ~Private() {
  42         qDeleteAll(subhunks);
  43     }
  44     QByteArray header;
  45     int lineNumber;
  46     QByteArray diff;
  47     int ref;
  48     int linesBefore, linesAfter;
  49
  50     QList<SubHunk *> subhunks;
  51
  52     QByteArray patchForAccepted(bool inverse);
  53 };
  54
  55 Hunk::Hunk()
  56     : d(new Private())
  57 {
  58 }
  59
  60 Hunk::Hunk(const Hunk &other)
  61     : d(other.d)
  62 {
  63     d->ref++;
  64 }
  65
  66 Hunk::~Hunk()
  67 {
  68     if (--d->ref == 0)
  69         delete d;
  70 }
  71
  72 void Hunk::addLine(const QByteArray &line)
  73 {
  74     if (line.size() == 0)
  75         return;
  76     if(d->header.isEmpty()) {
  77         d->header = line;
  78         QString header(line);
  79         QRegExp regexp("^@@ -[\\d,]+ \\+(\\d+)\\b");
  80         if (regexp.indexIn(header) != -1)
  81             d->lineNumber = regexp.cap(1).toInt();
  82         return;
  83     }
  84     if (line[0] == '\\') { // "\ No newline at end of file"
  85         if (d->diff.size())
  86             d->diff.chop(1); // TODO should that be 2 on Windows?
  87         return;
  88     }
  89     else if (line[0] != ' ') {
  90         SubHunk *last = d->subhunks[d->subhunks.count()-1];
  91         if (last->start < 0) {
  92             last->start = d->diff.size();
  93             last->lineNumber = d->lineNumber + qMax(d->linesBefore, d->linesAfter);
  94         }
  95         else if (last->start + last->length < d->diff.size()) {
  96             last = new SubHunk();
  97             d->subhunks.append(last);
  98             last->start = d->diff.size();
  99             last->lineNumber = d->lineNumber + qMax(d->linesBefore, d->linesAfter);
 100         }
 101         last->length+=line.length();
 102         if (line[0] == '-') {
 103             last->removed++;
 104             d->linesBefore++;
 105         }
 106         else {
 107             last->added++;
 108             d->linesAfter++;
 109         }
 110     }
 111     else {
 112         d->linesBefore++;
 113         d->linesAfter++;
 114     }
 115     d->diff.append(line);
 116 }
 117
 118 Hunk & Hunk::operator=(const Hunk &other)
 119 {
 120     other.d->ref++;
 121     if (--d->ref == 0)
 122         delete d;
 123     d = other.d;
 124     return *this;
 125 }
 126
 127 int Hunk::lineNumber() const
 128 {
 129     return d->lineNumber;
 130 }
 131
 132 int Hunk::lineNumber(int subHunk) const
 133 {
 134     Q_ASSERT(subHunk < d->subhunks.count());
 135     SubHunk *sh = d->subhunks[subHunk];
 136     return sh->lineNumber;
 137 }
 138
 139 QByteArray Hunk::patch() const
 140 {
 141     return d->diff;
 142 }
 143
 144 bool Hunk::isEmpty() const
 145 {
 146     return d->diff.isEmpty();
 147 }
 148
 149 Vng::Acceptance Hunk::acceptance() const
 150 {
 151     Vng::Acceptance a = Vng::Undecided;
 152     for (int i = 0; i < d->subhunks.count(); i++) {
 153         SubHunk *sh = d->subhunks[i];
 154         if (a != sh->accepted) {
 155             if (a == Vng::Undecided)
 156                 a = sh->accepted;
 157             else
 158                 return Vng::MixedAcceptance;
 159         }
 160     }
 161     return a;
 162 }
 163
 164 void Hunk::setAcceptance(Vng::Acceptance acceptance)
 165 {
 166     foreach(SubHunk *sh, d->subhunks)
 167         sh->accepted = acceptance;
 168 }
 169
 170 Vng::Acceptance Hunk::acceptance(int subHunk) const
 171 {
 172     Q_ASSERT(subHunk < d->subhunks.count());
 173     SubHunk *sh = d->subhunks[subHunk];
 174     return sh->accepted;
 175 }
 176
 177 void Hunk::setAcceptance(int subhunk, Vng::Acceptance accepted)
 178 {
 179     Q_ASSERT(subhunk < d->subhunks.count());
 180     SubHunk *sh = d->subhunks[subhunk];
 181     sh->accepted = accepted;
 182 }
 183
 184 QByteArray Hunk::header() const
 185 {
 186     return d->header;
 187 }
 188
 189 QByteArray Hunk::subHunk(int index) const
 190 {
 191     if (d->subhunks.count() == 0)
 192         return QByteArray();
 193     Q_ASSERT(index >= 0);
 194     Q_ASSERT(index < d->subhunks.count());
 195     SubHunk *sh = d->subhunks[index];
 196     return d->diff.mid(sh->start, sh->length);
 197 }
 198
 199 int Hunk::subHunkCount() const
 200 {
 201     return d->subhunks.count();
 202 }
 203
 204 QByteArray Hunk::rejectedPatch() const
 205 {
 206     return d->patchForAccepted(true);
 207 }
 208
 209 QByteArray Hunk::acceptedPatch() const
 210 {
 211     return d->patchForAccepted(false);
 212 }
 213
 214 QByteArray Hunk::Private::patchForAccepted(bool inverse)
 215 {
 216     QByteArray patch;
 217     QDataStream out (&patch, QIODevice::WriteOnly);
 218     const char *myDiff = diff.data();
 219     const char *space = " ";
 220     int offsetInDiff = 0; // position in diff
 221     int before = linesBefore; // for the header
 222     foreach(SubHunk *sh, subhunks) {
 223         out.writeRawData(myDiff + offsetInDiff, sh->start - offsetInDiff); //    write until start
 224         if (!inverse && sh->accepted == Vng::Accepted || inverse && sh->accepted != Vng::Accepted) {
 225             out.writeRawData(myDiff + sh->start, sh->length);
 226         }
 227         else {
 228             const int end = sh->start + sh->length;
 229             bool startOfLine = true;
 230             bool skipLine;
 231             int lastLineStart = 0;
 232             for (int x = sh->start; x < end; x++) {
 233                 if (startOfLine) {
 234                     startOfLine = false;
 235                     skipLine = myDiff[x] == '-';
 236                     if (! skipLine) {
 237                         out.writeRawData(space, 1);
 238                         lastLineStart = x + 1;
 239                     }
 240                     continue;
 241                 }
 242                 if (myDiff[x] == '\n') {
 243                     startOfLine = true;
 244                     if (! skipLine)
 245                         out.writeRawData(myDiff + lastLineStart, x - lastLineStart + 1);
 246                 }
 247             }
 248             before += sh->added - sh->removed;
 249         }
 250         offsetInDiff = sh->start + sh->length;
 251     }
 252     out.writeRawData(myDiff + offsetInDiff, diff.size() - offsetInDiff);
 253
 254     // create header
 255     QString header = "@@ -"+ QString::number(lineNumber) +","+ QString::number(before)
 256         +" +"+ QString::number(lineNumber) +","+  QString::number(linesAfter) + " @@\n";
 257
 258     QByteArray answer;
 259     answer.append(header);
 260     answer.append(patch);
 261     return answer;
 262 }
 263
 264 int Hunk::linesAdded() const
 265 {
 266     int total = 0;
 267     foreach(SubHunk *sh, d->subhunks)
 268         total += sh->added;
 269     return total;
 270 }
 271
 272 int Hunk::linesRemoved() const
 273 {
 274     int total = 0;
 275     foreach(SubHunk *sh, d->subhunks)
 276         total += sh->removed;
 277     return total;
 278 }