File indexing completed on 2024-05-26 13:37:33

0001 // clang-format off
0002 /*
0003  * KDiff3 - Text Diff And Merge Tool
0004  *
0005  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
0006  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
0007  * SPDX-License-Identifier: GPL-2.0-or-later
0008  */
0009 // clang-format on
0010 
0011 #include "MergeEditLine.h"
0012 
0013 #include "diff.h"
0014 #include "LineRef.h"
0015 
0016 #include <memory>
0017 #include <optional>
0018 #include <vector>
0019 
0020 QString MergeEditLine::getString(const std::shared_ptr<const LineDataVector> &pLineDataA, const std::shared_ptr<const LineDataVector> &pLineDataB, const std::shared_ptr<const LineDataVector> &pLineDataC) const
0021 {
0022     //Triggered by resize event during early init. Ignore these calls.
0023     if((mSrc == e_SrcSelector::A && pLineDataA->empty()) || (mSrc == e_SrcSelector::B && pLineDataB->empty()) || (mSrc == e_SrcSelector::C && pLineDataC->empty()))
0024         return QString();
0025 
0026     if(isRemoved() || (!isModified() && mSrc == e_SrcSelector::None))
0027     {
0028         return QString();
0029     }
0030 
0031     if(!isModified())
0032     {
0033         std::optional<LineData> lineData;
0034         assert(mSrc == e_SrcSelector::A || mSrc == e_SrcSelector::B || mSrc == e_SrcSelector::C);
0035 
0036         if(mSrc == e_SrcSelector::A && m_id3l->getLineA().isValid())
0037             lineData = (*pLineDataA)[m_id3l->getLineA()];
0038         else if(mSrc == e_SrcSelector::B && m_id3l->getLineB().isValid())
0039             lineData = (*pLineDataB)[m_id3l->getLineB()];
0040         else if(mSrc == e_SrcSelector::C && m_id3l->getLineC().isValid())
0041             lineData = (*pLineDataC)[m_id3l->getLineC()];
0042 
0043         //Not an error.
0044         if(!lineData.has_value())
0045         {
0046             return QString();
0047         }
0048 
0049         return lineData->getLine();
0050     }
0051 
0052     return mStr;
0053 }
0054 
0055 bool MergeBlock::isSameKind(const MergeBlock &mb2) const
0056 {
0057     if(bConflict && mb2.bConflict)
0058     {
0059         // Both lines have conflicts: If one is only a white space conflict and
0060         // the other one is a real conflict, then this line returns false.
0061         return mId3l->isEqualAC() == mb2.mId3l->isEqualAC() && mId3l->isEqualAB() == mb2.mId3l->isEqualAB();
0062     }
0063     else
0064         return (
0065             (!bConflict && !mb2.bConflict && bDelta && mb2.bDelta && srcSelect == mb2.srcSelect && (mergeDetails == mb2.mergeDetails || (mergeDetails != e_MergeDetails::eBCAddedAndEqual && mb2.mergeDetails != e_MergeDetails::eBCAddedAndEqual))) ||
0066             (!bDelta && !mb2.bDelta));
0067 }
0068 
0069 // Calculate the merge information for the given Diff3Line.
0070 // Results will be stored in this and bLineRemoved.
0071 void MergeBlock::mergeOneLine(const Diff3Line &diffRec, bool &bLineRemoved, bool bTwoInputs)
0072 {
0073     mergeDetails = e_MergeDetails::eDefault;
0074     bConflict = false;
0075     bLineRemoved = false;
0076     srcSelect = e_SrcSelector::None;
0077 
0078     if(bTwoInputs) // Only two input files
0079     {
0080         if(diffRec.getLineA().isValid() && diffRec.getLineB().isValid())
0081         {
0082             if(!diffRec.hasFineDiffAB())
0083             {
0084                 mergeDetails = e_MergeDetails::eNoChange;
0085                 srcSelect = e_SrcSelector::A;
0086             }
0087             else
0088             {
0089                 mergeDetails = e_MergeDetails::eBChanged;
0090                 bConflict = true;
0091             }
0092         }
0093         else
0094         {
0095             mergeDetails = e_MergeDetails::eBDeleted;
0096             bConflict = true;
0097         }
0098         return;
0099     }
0100 
0101     // A is base.
0102     if(diffRec.getLineA().isValid() && diffRec.getLineB().isValid() && diffRec.getLineC().isValid())
0103     {
0104         if(!diffRec.hasFineDiffAB() && !diffRec.hasFineDiffBC() && !diffRec.hasFineDiffCA())
0105         {
0106             mergeDetails = e_MergeDetails::eNoChange;
0107             srcSelect = e_SrcSelector::A;
0108         }
0109         else if(!diffRec.hasFineDiffAB() && diffRec.hasFineDiffBC() && diffRec.hasFineDiffCA())
0110         {
0111             mergeDetails = e_MergeDetails::eCChanged;
0112             srcSelect = e_SrcSelector::C;
0113         }
0114         else if(diffRec.hasFineDiffAB() && diffRec.hasFineDiffBC() && !diffRec.hasFineDiffCA())
0115         {
0116             mergeDetails = e_MergeDetails::eBChanged;
0117             srcSelect = e_SrcSelector::B;
0118         }
0119         else if(diffRec.hasFineDiffAB() && !diffRec.hasFineDiffBC() && diffRec.hasFineDiffCA())
0120         {
0121             mergeDetails = e_MergeDetails::eBCChangedAndEqual;
0122             srcSelect = e_SrcSelector::C;
0123         }
0124         else if(diffRec.hasFineDiffAB() && diffRec.hasFineDiffBC() && diffRec.hasFineDiffCA())
0125         {
0126             mergeDetails = e_MergeDetails::eBCChanged;
0127             bConflict = true;
0128         }
0129         else
0130         {
0131             assert(false);
0132         }
0133     }
0134     else if(diffRec.getLineA().isValid() && diffRec.getLineB().isValid() && !diffRec.getLineC().isValid())
0135     {
0136         if(diffRec.hasFineDiffAB())
0137         {
0138             mergeDetails = e_MergeDetails::eBChanged_CDeleted;
0139             bConflict = true;
0140         }
0141         else
0142         {
0143             mergeDetails = e_MergeDetails::eCDeleted;
0144             bLineRemoved = true;
0145             srcSelect = e_SrcSelector::C;
0146         }
0147     }
0148     else if(diffRec.getLineA().isValid() && !diffRec.getLineB().isValid() && diffRec.getLineC().isValid())
0149     {
0150         if(diffRec.hasFineDiffCA())
0151         {
0152             mergeDetails = e_MergeDetails::eCChanged_BDeleted;
0153             bConflict = true;
0154         }
0155         else
0156         {
0157             mergeDetails = e_MergeDetails::eBDeleted;
0158             bLineRemoved = true;
0159             srcSelect = e_SrcSelector::B;
0160         }
0161     }
0162     else if(!diffRec.getLineA().isValid() && diffRec.getLineB().isValid() && diffRec.getLineC().isValid())
0163     {
0164         if(diffRec.hasFineDiffBC())
0165         {
0166             mergeDetails = e_MergeDetails::eBCAdded;
0167             bConflict = true;
0168         }
0169         else // B==C
0170         {
0171             mergeDetails = e_MergeDetails::eBCAddedAndEqual;
0172             srcSelect = e_SrcSelector::C;
0173         }
0174     }
0175     else if(!diffRec.getLineA().isValid() && !diffRec.getLineB().isValid() && diffRec.getLineC().isValid())
0176     {
0177         mergeDetails = e_MergeDetails::eCAdded;
0178         srcSelect = e_SrcSelector::C;
0179     }
0180     else if(!diffRec.getLineA().isValid() && diffRec.getLineB().isValid() && !diffRec.getLineC().isValid())
0181     {
0182         mergeDetails = e_MergeDetails::eBAdded;
0183         srcSelect = e_SrcSelector::B;
0184     }
0185     else if(diffRec.getLineA().isValid() && !diffRec.getLineB().isValid() && !diffRec.getLineC().isValid())
0186     {
0187         mergeDetails = e_MergeDetails::eBCDeleted;
0188         bLineRemoved = true;
0189         srcSelect = e_SrcSelector::C;
0190     }
0191     else
0192         assert(false);
0193 }
0194 /*
0195     Build a new MergeBlockList from scratch using a Diff3LineList.
0196 */
0197 void MergeBlockList::buildFromDiff3(const Diff3LineList &diff3List, bool isThreeway)
0198 {
0199     LineType lineIdx = 0;
0200     for(auto it = diff3List.cbegin(); it != diff3List.cend(); ++it)
0201     {
0202         const Diff3Line &d = *it;
0203         MergeBlock mb;
0204         bool bLineRemoved;
0205 
0206         mb.mergeOneLine(d, bLineRemoved, !isThreeway);
0207         mb.dectectWhiteSpaceConflict(d, isThreeway);
0208 
0209         mb.d3lLineIdx = lineIdx;
0210         mb.bDelta = mb.srcSelect != e_SrcSelector::A;
0211         mb.mId3l = it;
0212         mb.srcRangeLength = 1;
0213 
0214         MergeBlock *lBack = empty() ? nullptr : &back();
0215 
0216         bool bSame = lBack != nullptr && mb.isSameKind(*lBack);
0217         if(bSame)
0218         {
0219             ++lBack->srcRangeLength;
0220             if(lBack->isWhiteSpaceConflict() && !mb.isWhiteSpaceConflict())
0221                 lBack->bWhiteSpaceConflict = false;
0222         }
0223         else
0224         {
0225             push_back(mb);
0226         }
0227 
0228         if(!mb.isConflict())
0229         {
0230             MergeBlock &tmpBack = back();
0231             MergeEditLine mel(mb.id3l());
0232             mel.setSource(mb.srcSelect, bLineRemoved);
0233             tmpBack.list().push_back(mel);
0234         }
0235         else if(lBack == nullptr || !lBack->isConflict() || !bSame)
0236         {
0237             MergeBlock &tmpBack = back();
0238             MergeEditLine mel(mb.id3l());
0239             mel.setConflict();
0240             tmpBack.list().push_back(mel);
0241         }
0242 
0243         ++lineIdx;
0244     }
0245 }
0246 /*
0247     Changes default merge settings currently used when not in auto mode or if white space is being auto solved.
0248 */
0249 void MergeBlockList::updateDefaults(const e_SrcSelector defaultSelector, const bool bConflictsOnly, const bool bWhiteSpaceOnly)
0250 {
0251     // Change all auto selections
0252     MergeBlockList::iterator mbIt;
0253     for(mbIt = begin(); mbIt != end(); ++mbIt)
0254     {
0255         MergeBlock &mb = *mbIt;
0256         bool bConflict = mb.list().empty() || mb.list().begin()->isConflict();
0257         if(mb.isDelta() && !(mb.hasModfiedText() && (bConflictsOnly || bWhiteSpaceOnly)) && (!bConflictsOnly || bConflict) && (!bWhiteSpaceOnly || mb.isWhiteSpaceConflict()))
0258         {
0259             mb.list().clear();
0260             if(defaultSelector == e_SrcSelector::Invalid)
0261             {
0262                 MergeEditLine mel(mb.id3l());
0263 
0264                 mel.setConflict();
0265                 mb.bConflict = true;
0266                 mb.list().push_back(mel);
0267             }
0268             else
0269             {
0270                 Diff3LineList::const_iterator d3llit = mb.id3l();
0271                 qint32 j;
0272 
0273                 for(j = 0; j < mb.srcRangeLength; ++j)
0274                 {
0275                     MergeEditLine mel(d3llit);
0276                     mel.setSource(defaultSelector, false);
0277 
0278                     LineRef srcLine = defaultSelector == e_SrcSelector::A ? d3llit->getLineA() : defaultSelector == e_SrcSelector::B ? d3llit->getLineB() :
0279                                                                                              defaultSelector == e_SrcSelector::C     ? d3llit->getLineC() :
0280                                                                                                                                        LineRef();
0281                     if(srcLine.isValid())
0282                     {
0283                         mb.list().push_back(mel);
0284                     }
0285 
0286                     ++d3llit;
0287                 }
0288 
0289                 if(mb.list().empty()) // Make a line nevertheless
0290                 {
0291                     MergeEditLine mel(mb.id3l());
0292                     mel.setRemoved(defaultSelector);
0293                     mb.list().push_back(mel);
0294                 }
0295             }
0296         }
0297     }
0298 }
0299 
0300 void MergeBlock::dectectWhiteSpaceConflict(const Diff3Line &d, const bool isThreeWay)
0301 {
0302     // Automatic solving for only whitespace changes.
0303     if(isConflict() &&
0304        ((!isThreeWay && (d.isEqualAB() || (d.isWhiteLine(e_SrcSelector::A) && d.isWhiteLine(e_SrcSelector::B)))) ||
0305         (isThreeWay && ((d.isEqualAB() && d.isEqualAC()) || (d.isWhiteLine(e_SrcSelector::A) && d.isWhiteLine(e_SrcSelector::B) && d.isWhiteLine(e_SrcSelector::C))))))
0306     {
0307         bWhiteSpaceConflict = true;
0308     }
0309 }
0310 // Remove all lines that are empty, because no src lines are there.
0311 void MergeBlock::removeEmptySource()
0312 {
0313     LineRef oldSrcLine;
0314     e_SrcSelector oldSrc = e_SrcSelector::Invalid;
0315     MergeEditLineList::iterator melIt;
0316     for(melIt = list().begin(); melIt != list().end();)
0317     {
0318         MergeEditLine& mel = *melIt;
0319         e_SrcSelector melsrc = mel.src();
0320 
0321         LineRef srcLine = mel.isRemoved() ? LineRef() : melsrc == e_SrcSelector::A ? mel.id3l()->getLineA() : melsrc == e_SrcSelector::B ? mel.id3l()->getLineB() : melsrc == e_SrcSelector::C ? mel.id3l()->getLineC() : LineRef();
0322 
0323         // At least one line remains because oldSrc != melsrc for first line in list
0324         // Other empty lines will be removed
0325         if(!srcLine.isValid() && !oldSrcLine.isValid() && oldSrc == melsrc)
0326             melIt = list().erase(melIt);
0327         else
0328             ++melIt;
0329 
0330         oldSrcLine = srcLine;
0331         oldSrc = melsrc;
0332     }
0333 }
0334 
0335 // Returns the iterator to the MergeBlock after the split
0336 MergeBlockList::iterator MergeBlockList::splitAtDiff3LineIdx(qint32 d3lLineIdx)
0337 {
0338     MergeBlockList::iterator i;
0339     for(i = begin(); i != end(); ++i)
0340     {
0341         if(i->getIndex() == d3lLineIdx)
0342         {
0343             // No split needed, this is the beginning of a MergeBlock
0344             return i;
0345         }
0346         else if(i->getIndex() > d3lLineIdx)
0347         {
0348             // The split must be in the previous MergeBlock
0349             --i;
0350             MergeBlock &mb = *i;
0351             MergeBlock newMB;
0352             mb.split(newMB, d3lLineIdx);
0353             ++i;
0354             return insert(i, newMB);
0355         }
0356     }
0357     // The split must be in the previous MergeBlock
0358     --i;
0359     MergeBlock &mb = *i;
0360     MergeBlock newMB;
0361     mb.split(newMB, d3lLineIdx);
0362     ++i;
0363     return insert(i, newMB);
0364 }