src/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 {
  26 public:
  27     SubHunk() : start(-1), length(0), accepted(Vng::Undecided), added(0), removed(0) { }
  28     int start, length;
  29     Vng::Acceptance accepted;
  30     int added, removed;
  31     int lineNumber;
  32 };
  33
  34 class Hunk::Private
  35 {
  36 public:
  37     Private() : lineNumber(-1), ref(1), linesBefore(0), linesAfter(0)
  38     {
  39         SubHunk *sh = new SubHunk();
  40         subhunks.append(sh);
  41     }
  42
  43     ~Private() {
  44         qDeleteAll(subhunks);
  45     }
  46     QByteArray header;
  47     int lineNumber;
  48     QByteArray diff;
  49 #if QT_VERSION >= 0x040400
  50     QAtomicInt ref;
  51 #else
  52     int ref;
  53 #endif
  54     int linesBefore, linesAfter;
  55
  56     QList<SubHunk *> subhunks;
  57
  58     QByteArray patchForAccepted(bool inverse);
  59 };
  60
  61 Hunk::Hunk()
  62     : d(new Private())
  63 {
  64 }
  65
  66 Hunk::Hunk(const Hunk &other)
  67     : d(other.d)
  68 {
  69 #if QT_VERSION >= 0x040400
  70     d->ref.ref();
  71 #else
  72     d->ref++;
  73 #endif
  74 }
  75
  76 Hunk::~Hunk()
  77 {
  78 #if QT_VERSION >= 0x040400
  79     if (!d->ref.deref())
  80 #else
  81     if (--d->ref == 0)
  82 #endif
  83         delete d;
  84 }
  85
  86 void Hunk::addLine(const QByteArray &line)
  87 {
  88     if (line.size() == 0)
  89         return;
  90     if(d->header.isEmpty()) {
  91         d->header = line;
  92         QString header(line);
  93         QRegExp regexp("^@@ -[\\d,]+ \\+(\\d+)\\b");
  94         if (regexp.indexIn(header) != -1)
  95             d->lineNumber = regexp.cap(1).toInt();
  96         return;
  97     }
  98     if (line[0] == '\\') { // "\ No newline at end of file"
  99         if (d->diff.size()) {
 100             // check if we removed something from the last hunk and adjust its size
 101             SubHunk *last = d->subhunks[d->subhunks.count()-1];
 102             if (last->start + last->length == d->diff.size())
 103                 --last->length;
 104             d->diff.chop(1); // TODO should that be 2 on Windows?
 105         }
 106         return;
 107     }
 108     else if (line[0] != ' ') {
 109         SubHunk *last = d->subhunks[d->subhunks.count()-1];
 110         if (last->start < 0) {
 111             last->start = d->diff.size();
 112             last->lineNumber = d->lineNumber + qMax(d->linesBefore, d->linesAfter);
 113         }
 114         else if (last->start + last->length < d->diff.size()) {
 115             last = new SubHunk();
 116             d->subhunks.append(last);
 117             last->start = d->diff.size();
 118             last->lineNumber = d->lineNumber + qMax(d->linesBefore, d->linesAfter);
 119         }
 120         last->length+=line.length();
 121         if (line[0] == '-') {
 122             last->removed++;
 123             d->linesBefore++;
 124         }
 125         else {
 126             last->added++;
 127             d->linesAfter++;
 128         }
 129     }
 130     else {
 131         d->linesBefore++;
 132         d->linesAfter++;
 133     }
 134     d->diff.append(line);
 135 }
 136
 137 Hunk & Hunk::operator=(const Hunk &other)
 138 {
 139 #if QT_VERSION >= 0x040400
 140     other.d->ref.ref();
 141     if (! d->ref.deref())
 142 #else
 143     other.d->ref++;
 144     if (--d->ref == 0)
 145 #endif
 146         delete d;
 147     d = other.d;
 148     return *this;
 149 }
 150
 151 int Hunk::lineNumber() const
 152 {
 153     return d->lineNumber;
 154 }
 155
 156 int Hunk::lineNumber(int subHunk) const
 157 {
 158     Q_ASSERT(subHunk < d->subhunks.count());
 159     SubHunk *sh = d->subhunks[subHunk];
 160     return sh->lineNumber;
 161 }
 162
 163 QByteArray Hunk::patch() const
 164 {
 165     return d->diff;
 166 }
 167
 168 bool Hunk::isEmpty() const
 169 {
 170     return d->diff.isEmpty();
 171 }
 172
 173 Vng::Acceptance Hunk::acceptance() const
 174 {
 175     Vng::Acceptance a = Vng::Undecided;
 176     for (int i = 0; i < d->subhunks.count(); i++) {
 177         SubHunk *sh = d->subhunks[i];
 178         if (a != sh->accepted) {
 179             if (a == Vng::Undecided)
 180                 a = sh->accepted;
 181             else
 182                 return Vng::MixedAcceptance;
 183         }
 184     }
 185     return a;
 186 }
 187
 188 void Hunk::setAcceptance(Vng::Acceptance acceptance)
 189 {
 190     foreach(SubHunk *sh, d->subhunks)
 191         sh->accepted = acceptance;
 192 }
 193
 194 Vng::Acceptance Hunk::acceptance(int subHunk) const
 195 {
 196     Q_ASSERT(subHunk < d->subhunks.count());
 197     SubHunk *sh = d->subhunks[subHunk];
 198     return sh->accepted;
 199 }
 200
 201 void Hunk::setAcceptance(int subhunk, Vng::Acceptance accepted)
 202 {
 203     Q_ASSERT(subhunk < d->subhunks.count());
 204     SubHunk *sh = d->subhunks[subhunk];
 205     sh->accepted = accepted;
 206 }
 207
 208 QByteArray Hunk::header() const
 209 {
 210     return d->header;
 211 }
 212
 213 QByteArray Hunk::subHunk(int index) const
 214 {
 215     if (d->subhunks.count() == 0)
 216         return QByteArray();
 217     Q_ASSERT(index >= 0);
 218     Q_ASSERT(index < d->subhunks.count());
 219     SubHunk *sh = d->subhunks[index];
 220     return d->diff.mid(sh->start, sh->length);
 221 }
 222
 223 int Hunk::subHunkCount() const
 224 {
 225     return d->subhunks.count();
 226 }
 227
 228 QByteArray Hunk::rejectedPatch() const
 229 {
 230     return d->patchForAccepted(true);
 231 }
 232
 233 QByteArray Hunk::acceptedPatch() const
 234 {
 235     return d->patchForAccepted(false);
 236 }
 237
 238 QByteArray Hunk::Private::patchForAccepted(bool inverse)
 239 {
 240     QByteArray patch;
 241     QDataStream out (&patch, QIODevice::WriteOnly);
 242     const char *myDiff = diff.data();
 243     const char *space = " ";
 244     int offsetInDiff = 0; // position in diff
 245     int before = linesBefore; // for the header
 246     foreach(SubHunk *sh, subhunks) {
 247         out.writeRawData(myDiff + offsetInDiff, sh->start - offsetInDiff); //    write until start
 248         if ((!inverse && sh->accepted == Vng::Accepted) || (inverse && sh->accepted != Vng::Accepted)) {
 249             out.writeRawData(myDiff + sh->start, sh->length);
 250         }
 251         else {
 252             const int end = sh->start + sh->length;
 253             bool startOfLine = true;
 254             bool skipLine = false;
 255             int lastLineStart = 0;
 256             for (int x = sh->start; x < end; x++) {
 257                 if (startOfLine) {
 258                     startOfLine = false;
 259                     skipLine = (myDiff[x] == '-');
 260                     if (! skipLine) {
 261                         out.writeRawData(space, 1);
 262                         lastLineStart = x + 1;
 263                     }
 264                     continue;
 265                 }
 266                 if (myDiff[x] == '\n') {
 267                     startOfLine = true;
 268                     if (! skipLine)
 269                         out.writeRawData(myDiff + lastLineStart, x - lastLineStart + 1);
 270                 }
 271             }
 272             before += sh->added - sh->removed;
 273         }
 274         offsetInDiff = sh->start + sh->length;
 275     }
 276     Q_ASSERT(offsetInDiff <= diff.size());
 277     out.writeRawData(myDiff + offsetInDiff, diff.size() - offsetInDiff);
 278     if (patch[patch.size() -1] != '\n') {
 279         const char *noNewLine = "\n\\ No newline at end of file\n";;
 280         out.writeRawData(noNewLine, strlen(noNewLine));
 281     }
 282
 283     // create header
 284     QString header = "@@ -"+ QString::number(lineNumber) +","+ QString::number(before)
 285         +" +"+ QString::number(lineNumber) +","+  QString::number(linesAfter) + " @@\n";
 286
 287     QByteArray answer;
 288     answer.append(header.toLocal8Bit());
 289     answer.append(patch);
 290     return answer;
 291 }
 292
 293 int Hunk::linesAdded() const
 294 {
 295     int total = 0;
 296     foreach(SubHunk *sh, d->subhunks)
 297         total += sh->added;
 298     return total;
 299 }
 300
 301 int Hunk::linesRemoved() const
 302 {
 303     int total = 0;
 304     foreach(SubHunk *sh, d->subhunks)
 305         total += sh->removed;
 306     return total;
 307 }