kross/krossdistributedversioncontrol.cpp

   1 /* KDevPlatform Kross Support
   2  *
   3  * Copyright 2008 Aleix Pol <aleixpol@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (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, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA.
  19  */
  20
  21 #include "krossdistributedversioncontrol.h"
  22 #include <KDebug>
  23 #include <KAction>
  24 #include <KLocale>
  25 #include <QMenu>
  26
  27 #include <interfaces/iplugin.h>
  28 #include <kross/core/action.h>
  29 #include <interfaces/context.h>
  30 #include <project/projectmodel.h>
  31 #include "krossvcsjob.h"
  32 #include "wrappers/krossvcsrevision.h"
  33 #include "wrappers/krossvcslocation.h"
  34
  35 using namespace KDevelop;
  36
  37 KrossDistributedVersionControl::KrossDistributedVersionControl(KDevelop::IPlugin* plugin)
  38     : action(0), m_plugin(plugin)
  39 {
  40 }
  41
  42 KrossDistributedVersionControl::~KrossDistributedVersionControl()
  43 {
  44 }
  45
  46 void KrossDistributedVersionControl::setActionDistributed(Kross::Action* anAction)
  47 {
  48     action=anAction;
  49 }
  50
  51 QString KrossDistributedVersionControl::name() const
  52 {
  53     QVariantList args;
  54     QVariant result=action->callFunction("name", args );
  55     kDebug() << "retrieving name" << result.toString();
  56     return result.toString();
  57 }
  58
  59 KDevelop::VcsImportMetadataWidget * KrossDistributedVersionControl::createImportMetadataWidget(QWidget *)
  60 {
  61     return 0;
  62 }
  63
  64 bool KrossDistributedVersionControl::isVersionControlled(const KUrl & url)
  65 {
  66     QVariantList args;
  67     args << QUrl(url);
  68     QVariant result=action->callFunction( "isVersionControlled", args);
  69     return result.toBool();
  70 }
  71
  72 KDevelop::VcsJob * KrossDistributedVersionControl::add(const KUrl::List & files, KDevelop::IBasicVersionControl::RecursionMode mode = IBasicVersionControl::Recursive)
  73 {
  74     QVariant param(files);
  75     QVariant param1(mode==Recursive);
  76
  77     return new KrossVcsJob("add", QVariantList() << param << param1, action, m_plugin, action);
  78 }
  79
  80 KDevelop::VcsJob * KrossDistributedVersionControl::remove(const KUrl::List & files)
  81 {
  82     QVariant param(files);
  83
  84     return new KrossVcsJob("remove", QVariantList() << param, action, m_plugin, action);
  85 }
  86
  87 KDevelop::VcsJob * KrossDistributedVersionControl::copy(const KUrl & file, const KUrl & newfile)
  88 {
  89     QVariant from(file);
  90     QVariant to(newfile);
  91
  92     return new KrossVcsJob("copy", QVariantList() << from << to, action, m_plugin, action);
  93 }
  94
  95 KDevelop::VcsJob * KrossDistributedVersionControl::move(const KUrl & file, const KUrl & newfile)
  96 {
  97     QVariant from(file);
  98     QVariant to(newfile);
  99
 100     return new KrossVcsJob("move", QVariantList() << from << to, action, m_plugin, action);
 101 }
 102
 103 KDevelop::VcsJob * KrossDistributedVersionControl::status(const KUrl::List & files, KDevelop::IBasicVersionControl::RecursionMode mode)
 104 {
 105     QVariant param(files);
 106     QVariant param1(mode);
 107
 108     return new KrossVcsJob("status", QVariantList() << param << param1, action, m_plugin, action);
 109 }
 110
 111 KDevelop::VcsJob * KrossDistributedVersionControl::revert(const KUrl::List & files, KDevelop::IBasicVersionControl::RecursionMode mode)
 112 {
 113     QVariant param(files);
 114     QVariant param1(mode==Recursive);
 115
 116     return new KrossVcsJob("revert", QVariantList() << param << param1, action, m_plugin, action);
 117 }
 118
 119 KDevelop::VcsJob * KrossDistributedVersionControl::update(const KUrl::List & localLocations, const KDevelop::VcsRevision & rev,
 120                                                             KDevelop::IBasicVersionControl::RecursionMode rec)
 121 {
 122     QVariant revision=Handlers::kDevelopVcsRevisionHandler(&rev);
 123
 124     QVariantList parameters;
 125     parameters.append(QVariant(localLocations));
 126     parameters.append(revision);
 127     parameters.append(QVariant(rec));
 128
 129     return new KrossVcsJob("update", parameters, action, m_plugin, action);
 130     return 0;
 131 }
 132
 133 KDevelop::VcsJob * KrossDistributedVersionControl::commit(const QString & msg, const KUrl::List & files,
 134                                                           KDevelop::IBasicVersionControl::RecursionMode mode)
 135 {
 136     QVariant message(msg);
 137     QVariant file(files);
 138     QVariant recursion(mode);
 139
 140     return new KrossVcsJob("commit", QVariantList() << message << file << mode, action, m_plugin, action);
 141 }
 142
 143 KDevelop::VcsJob * KrossDistributedVersionControl::diff(const KUrl::List & files, KDevelop::VcsRevision & rev,
 144                                                         KDevelop::IBasicVersionControl::RecursionMode mode)
 145 {
 146     QVariant revision=Handlers::kDevelopVcsRevisionHandler(&rev);
 147
 148     return new KrossVcsJob("commit", QVariantList() << files << revision << mode, action, m_plugin, action);
 149 }
 150
 151 KDevelop::VcsJob * KrossDistributedVersionControl::repositoryLocation(const KUrl::List & files)
 152 {
 153     return new KrossVcsJob("repositoryLocation", QVariantList() << files, action, m_plugin, action);
 154 }
 155
 156 KDevelop::VcsJob * KrossDistributedVersionControl::repositoryLocation(const KUrl & localLocation)
 157 {
 158     return new KrossVcsJob("repositoryLocation", QVariantList() << localLocation, action, m_plugin, action);
 159 }
 160
 161 KDevelop::VcsJob * KrossDistributedVersionControl::diff(const KDevelop::VcsLocation & localOrRepoLocationSrc,
 162                                                         const KDevelop::VcsLocation & localOrRepoLocationDst,
 163                                                         const KDevelop::VcsRevision & srcRevision,
 164                                                         const KDevelop::VcsRevision & dstRevision,
 165                                                         KDevelop::VcsDiff::Type t,
 166                                                         KDevelop::IBasicVersionControl::RecursionMode recursion)
 167 {
 168     QVariant srcrev=Handlers::kDevelopVcsRevisionHandler(&srcRevision);
 169     QVariant dstrev=Handlers::kDevelopVcsRevisionHandler(&dstRevision);
 170
 171     QVariant srcloc=Handlers::kDevelopVcsLocationHandler(&localOrRepoLocationSrc);
 172     QVariant dstloc=Handlers::kDevelopVcsLocationHandler(&localOrRepoLocationDst);
 173
 174     return new KrossVcsJob("repositoryLocation",
 175                                          QVariantList() << srcloc << dstloc << srcrev << dstrev << QVariant(t) << QVariant(recursion), action, m_plugin, action);
 176     return 0;
 177 }
 178
 179 KDevelop::VcsJob * KrossDistributedVersionControl::log(const KUrl & file, const KDevelop::VcsRevision & rev, long unsigned int limit)
 180 {
 181     QVariant revision=Handlers::kDevelopVcsRevisionHandler(&rev);
 182
 183     return new KrossVcsJob("log", QVariantList() << file << revision << qlonglong(limit), action, m_plugin, action);
 184 }
 185
 186 VcsJob* KrossDistributedVersionControl::log(const KUrl& file, const VcsRevision& rev, const VcsRevision& lim)
 187 {
 188     QVariant revision=Handlers::kDevelopVcsRevisionHandler(&rev);
 189     QVariant limit=Handlers::kDevelopVcsRevisionHandler(&lim);
 190
 191     return new KrossVcsJob("log", QVariantList() << file << revision << limit, action, m_plugin, action);
 192 }
 193
 194 VcsJob* KrossDistributedVersionControl::annotate(const KUrl& file, const VcsRevision& rev)
 195 {
 196     QVariant revision=Handlers::kDevelopVcsRevisionHandler(&rev);
 197
 198     return new KrossVcsJob("annotate", QVariantList() << file << revision, action, m_plugin, action);
 199 }
 200
 201 VcsJob* KrossDistributedVersionControl::merge(const VcsLocation& localOrRepoLocationSrc,
 202                                               const VcsLocation& localOrRepoLocationDst,
 203                                               const VcsRevision& srcRevision,
 204                                               const VcsRevision& dstRevision,
 205                                               const KUrl& localLocation )
 206 {
 207     QVariant srcrev=Handlers::kDevelopVcsRevisionHandler(&srcRevision);
 208     QVariant dstrev=Handlers::kDevelopVcsRevisionHandler(&dstRevision);
 209
 210     QVariant srcloc=Handlers::kDevelopVcsLocationHandler(&localOrRepoLocationSrc);
 211     QVariant dstloc=Handlers::kDevelopVcsLocationHandler(&localOrRepoLocationDst);
 212
 213     return new KrossVcsJob("merge", QVariantList() << srcloc << dstloc << srcrev << dstrev << localLocation, action, m_plugin, action);
 214
 215 }
 216
 217 VcsJob* KrossDistributedVersionControl::resolve( const KUrl::List& localLocations, KDevelop::IBasicVersionControl::RecursionMode recursion )
 218 {
 219     return new KrossVcsJob("resolve", QVariantList() << localLocations << recursion, action, m_plugin, action);
 220 }
 221
 222 VcsJob* KrossDistributedVersionControl::add_dvcs(const KUrl &repository,
 223                                                  const KUrl::List& localLocations)
 224 {
 225     return add(localLocations);
 226 }
 227
 228 VcsJob* KrossDistributedVersionControl::init(const KUrl& location)
 229 {
 230     return new KrossVcsJob("init", QVariantList() << location, action, m_plugin, action);
 231 }
 232
 233 VcsJob* KrossDistributedVersionControl::clone(const KDevelop::VcsLocation& localOrRepoLocationSrc, const KUrl& localRepositoryLocationSrc)
 234 {
 235     return new KrossVcsJob("clone", QVariantList() << localOrRepoLocationSrc.localUrl() << localRepositoryLocationSrc, action, m_plugin, action);
 236 }
 237
 238 VcsJob* KrossDistributedVersionControl::push(const KUrl& localRepositoryLocation, const KDevelop::VcsLocation& localOrRepoLocationDst)
 239 {
 240     return new KrossVcsJob("push", QVariantList() << localRepositoryLocation << localOrRepoLocationDst.localUrl(), action, m_plugin, action);
 241 }
 242
 243 VcsJob* KrossDistributedVersionControl::pull(const KDevelop::VcsLocation& localOrRepoLocationSrc, const KUrl& localRepositoryLocation)
 244 {
 245     return new KrossVcsJob("pull", QVariantList() << localOrRepoLocationSrc.localUrl() << localRepositoryLocation, action, m_plugin, action);
 246 }
 247
 248 VcsJob* KrossDistributedVersionControl::checkout(const KDevelop::VcsMapping& mapping)
 249 {
 250     //TODO empty QVarianList
 251     return new KrossVcsJob("checkout", QVariantList(), action, m_plugin, action);
 252 }
 253
 254 VcsJob* KrossDistributedVersionControl::reset(const KUrl &repository, const QStringList &args, const KUrl::List &files)
 255 {
 256     return new KrossVcsJob("checkout", QVariantList() << repository << args << files, action, m_plugin, action);
 257 }
 258
 259 #include "krossdistributedversioncontrol.moc"