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