File indexing completed on 2024-05-19 04:03:03

 /*
     SPDX-FileCopyrightText: 2017 René J.V. Bertin <rjvbertin@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "phabricatorjobs.h"
 #include "debug.h"
 
 #include <QDir>
 #include <QRegularExpression>
 #include <QStandardPaths>
 
 #include <KLocalizedString>
 
 const char s_colourCodes[] = "\u001B[[0-9]*m";
 
 using namespace Phabricator;
 
 bool DifferentialRevision::buildArcCommand(const QString &workDir, const QString &patchFile, bool doBrowse)
 {
     bool ret;
     QString arc = QStandardPaths::findExecutable(QStringLiteral("arc"));
     if (!arc.isEmpty()) {
         QStringList args;
         args << QStringLiteral("diff");
         if (m_id.isEmpty()) {
             // creating a new differential revision (review request)
             // the fact we skip "--create" means we'll be creating a new "differential diff"
             // which obliges the user to fill in the details we cannot provide through the plugin ATM.
             // TODO: grab the TARGET_GROUPS from .reviewboardrc and pass that via --reviewers
         } else {
             // updating an existing differential revision (review request)
             args << QStringLiteral("--update") << m_id;
         }
         args << QStringLiteral("--excuse") << QStringLiteral("patch submitted with the purpose/phabricator plugin");
         if (m_commit.isEmpty()) {
             args << QStringLiteral("--raw");
         } else {
             args << QStringLiteral("--allow-untracked") << QStringLiteral("--ignore-unsound-tests") << QStringLiteral("--nolint") << QStringLiteral("-nounit")
                  << QStringLiteral("--verbatim") << m_commit;
         }
         if (doBrowse) {
             args << QStringLiteral("--browse");
         }
         m_arcCmd.setProgram(arc);
         m_arcCmd.setArguments(args);
         if (!patchFile.isEmpty()) {
             m_arcCmd.setStandardInputFile(patchFile);
             m_arcInput = patchFile;
         }
         m_arcCmd.setWorkingDirectory(workDir);
         connect(&m_arcCmd, &QProcess::finished, this, &DifferentialRevision::done);
         setPercent(33);
         ret = true;
     } else {
         qCWarning(PLUGIN_PHABRICATOR) << "Could not find 'arc' in the path";
         setError(KJob::UserDefinedError + 3);
         setErrorText(i18n("Could not find the 'arc' command"));
         setErrorString(errorText());
         ret = false;
     }
     return ret;
 }
 
 void DifferentialRevision::start()
 {
     if (!m_arcCmd.program().isEmpty()) {
         qCDebug(PLUGIN_PHABRICATOR) << "starting" << m_arcCmd.program() << m_arcCmd.arguments();
         qCDebug(PLUGIN_PHABRICATOR) << "\twordDir=" << m_arcCmd.workingDirectory() << "stdin=" << m_arcInput;
         m_arcCmd.start();
         if (m_arcCmd.waitForStarted(5000)) {
             setPercent(66);
         }
     }
 }
 
 void DifferentialRevision::setErrorString(const QString &msg)
 {
     QRegularExpression unwanted(QString::fromUtf8(s_colourCodes));
     m_errorString = msg;
     m_errorString.replace(unwanted, QString());
 }
 
 QString DifferentialRevision::scrubbedResult()
 {
     QString result = QString::fromUtf8(m_arcCmd.readAllStandardOutput());
     // the return string can contain terminal text colour codes: remove them.
     QRegularExpression unwanted(QString::fromUtf8(s_colourCodes));
     result.replace(unwanted, QString());
     return result;
 }
 
 QStringList DifferentialRevision::scrubbedResultList()
 {
     QStringList result = QString::fromUtf8(m_arcCmd.readAllStandardOutput()).split(QChar::LineFeed);
     // the return string can contain terminal text colour codes: remove them.
     QRegularExpression unwanted(QString::fromUtf8(s_colourCodes));
     result.replaceInStrings(unwanted, QString());
     // remove all (now) empty strings
     result.removeAll(QString());
     return result;
 }
 
 NewDiffRev::NewDiffRev(const QUrl &patch, const QString &projectPath, bool doBrowse, QObject *parent)
     : DifferentialRevision(QString(), parent)
     , m_patch(patch)
     , m_project(projectPath)
 {
     buildArcCommand(projectPath, patch.toLocalFile(), doBrowse);
 }
 
 void NewDiffRev::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     if (exitStatus != QProcess::NormalExit || exitCode) {
         setError(KJob::UserDefinedError + exitCode);
         setErrorText(i18n("Could not create the new \"differential diff\""));
         setErrorString(QString::fromUtf8(m_arcCmd.readAllStandardError()));
         qCWarning(PLUGIN_PHABRICATOR) << "Could not create the new \"differential diff\":" << m_arcCmd.error() << ";" << errorString();
     } else {
         setPercent(99);
         const QString arcOutput = scrubbedResult();
         const char *diffOpCode = "Diff URI: ";
         int diffOffset = arcOutput.indexOf(QLatin1String(diffOpCode));
         if (diffOffset >= 0) {
             m_diffURI = arcOutput.mid(diffOffset + strlen(diffOpCode)).split(QChar::LineFeed).at(0);
         } else {
             m_diffURI = arcOutput;
         }
     }
 
     emitResult();
 }
 
 UpdateDiffRev::UpdateDiffRev(const QUrl &patch, const QString &basedir, const QString &id, const QString &updateComment, bool doBrowse, QObject *parent)
     : DifferentialRevision(id, parent)
     , m_patch(patch)
     , m_basedir(basedir)
 {
     buildArcCommand(m_basedir, m_patch.toLocalFile(), doBrowse);
     QStringList args = m_arcCmd.arguments();
     if (updateComment.isEmpty()) {
         args << QStringLiteral("--message") << QStringLiteral("<placeholder: patch updated via the purpose/phabricator plugin>");
     } else {
         args << QStringLiteral("--message") << updateComment;
     }
     m_arcCmd.setArguments(args);
 }
 
 void UpdateDiffRev::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     if (exitStatus != QProcess::NormalExit || exitCode) {
         setError(KJob::UserDefinedError + exitCode);
         setErrorText(i18n("Patch upload to Phabricator failed"));
         setErrorString(QString::fromUtf8(m_arcCmd.readAllStandardError()));
         qCWarning(PLUGIN_PHABRICATOR) << "Patch upload to Phabricator failed with exit code" << exitCode << ", error" << m_arcCmd.error() << ";"
                                       << errorString();
     } else {
         const QString arcOutput = scrubbedResult();
         const char *diffOpCode = "Revision URI: ";
         int diffOffset = arcOutput.indexOf(QLatin1String(diffOpCode));
         if (diffOffset >= 0) {
             m_diffURI = arcOutput.mid(diffOffset + strlen(diffOpCode)).split(QChar::LineFeed).at(0);
         } else {
             m_diffURI = arcOutput;
         }
     }
     emitResult();
 }
 
 DiffRevList::DiffRevList(const QString &projectDir, QObject *parent)
     : DifferentialRevision(QString(), parent)
     , m_projectDir(projectDir)
 {
     buildArcCommand(m_projectDir);
 }
 
 bool Phabricator::DiffRevList::buildArcCommand(const QString &workDir, const QString &unused, bool)
 {
     Q_UNUSED(unused)
     bool ret;
     QString arc = QStandardPaths::findExecutable(QStringLiteral("arc"));
     if (!arc.isEmpty()) {
         QStringList args;
         args << QStringLiteral("list");
         m_arcCmd.setProgram(arc);
         m_arcCmd.setArguments(args);
         m_arcCmd.setWorkingDirectory(workDir);
         connect(&m_arcCmd, &QProcess::finished, this, &DiffRevList::done);
         setPercent(33);
         ret = true;
     } else {
         qCWarning(PLUGIN_PHABRICATOR) << "Could not find 'arc' in the path";
         setError(KJob::UserDefinedError + 3);
         setErrorText(i18n("Could not find the 'arc' command"));
         setErrorString(errorText());
         ret = false;
     }
     return ret;
 }
 
 void DiffRevList::done(int exitCode, QProcess::ExitStatus exitStatus)
 {
     if (exitStatus != QProcess::NormalExit || exitCode) {
         setError(KJob::UserDefinedError + exitCode);
         setErrorText(i18n("Could not get list of differential revisions in %1", QDir::currentPath()));
         setErrorString(QString::fromUtf8(m_arcCmd.readAllStandardError()));
         qCWarning(PLUGIN_PHABRICATOR) << "Could not get list of differential revisions" << m_arcCmd.error() << ";" << errorString();
     } else {
         setPercent(99);
         const QStringList reviews = scrubbedResultList();
         qCDebug(PLUGIN_PHABRICATOR) << "arc list returned:" << reviews;
         const QRegularExpression revIDExpr(QStringLiteral(" D[0-9][0-9]*: "));
         for (auto rev : reviews) {
             int idStart = rev.indexOf(revIDExpr);
             if (idStart >= 0) {
                 QString revID = rev.mid(idStart + 1).split(QString::fromUtf8(": ")).at(0);
                 QString revTitle = rev.section(revIDExpr, 1);
                 if (rev.startsWith(QStringLiteral("* Accepted "))) {
                     // append a Unicode "Heavy Check Mark" to signal accepted revisions
                     revTitle += QStringLiteral(" ") + QString(QChar(0x2714));
                     m_statusMap[revTitle] = Accepted;
                 } else if (rev.startsWith(QStringLiteral("* Needs Revision "))) {
                     // append a Unicode "Heavy Ballot X" for lack of a Unicode glyph
                     // resembling the icon used on the Phab site.
                     revTitle += QStringLiteral(" ") + QString(QChar(0x2718));
                     m_statusMap[revTitle] = NeedsRevision;
                 } else if (rev.startsWith(QStringLiteral("* Needs Review "))) {
                     m_statusMap[revTitle] = NeedsReview;
                 }
                 m_reviews << qMakePair(revID, revTitle);
                 m_revMap[revTitle] = revID;
             }
         }
     }
     emitResult();
 }
 
 #include "moc_phabricatorjobs.cpp"