plugins/subversion/svnclient.cpp

   1 /***************************************************************************
   2  *   This file is part of KDevelop                                         *
   3  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
   4  *                                                                         *
   5  *   Parts of the file are copied from the RapidSvn C++ library            *
   6  *   Copyright (c) 2002-2006 The RapidSvn Group.  All rights reserved.     *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU Library General Public License as       *
  10  *   published by the Free Software Foundation; either version 2 of the    *
  11  *   License, or (at your option) any later version.                       *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU Library General Public     *
  19  *   License along with this program; if not, write to the                 *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  22  ***************************************************************************/
  23
  24 #include "svnclient.h"
  25
  26 #include <QDateTime>
  27 #include <QList>
  28
  29 #include <kdebug.h>
  30
  31 extern "C" {
  32 #include <svn_client.h>
  33 #include <svn_io.h>
  34 }
  35 #include "kdevsvncpp/targets.hpp"
  36 #include "kdevsvncpp/pool.hpp"
  37
  38 #include <kstandarddirs.h>
  39
  40 #include <vcs/vcsrevision.h>
  41 #include <vcs/vcsannotation.h>
  42
  43 void fail (apr_pool_t *pool, apr_status_t status, const char *fmt, ...)
  44 {
  45     va_list ap;
  46     char *msg;
  47     svn_error_t * error;
  48
  49     va_start (ap, fmt);
  50     msg = apr_pvsprintf (pool, fmt, ap);
  51     va_end (ap);
  52
  53     error = svn_error_create (status, NULL, msg);
  54     throw svn::ClientException (error);
  55 }
  56
  57 void cleanup( apr_file_t* outfile, const char* outfileName, apr_file_t* errfile, const char* errfileName, const svn::Pool& pool )
  58 {
  59     if( outfile != 0 )
  60     {
  61         apr_file_close( outfile );
  62     }
  63
  64     if( errfile != 0 )
  65     {
  66         apr_file_close( outfile );
  67     }
  68
  69     if( outfileName != 0 )
  70     {
  71         svn_error_clear( svn_io_remove_file ( outfileName, pool ) );
  72     }
  73
  74
  75     if( errfileName != 0 )
  76     {
  77         svn_error_clear( svn_io_remove_file ( errfileName, pool ) );
  78     }
  79
  80 }
  81
  82 SvnClient::SvnClient( svn::Context* ctx )
  83     : QObject(0), svn::Client( ctx ), m_ctxt( ctx )
  84 {
  85 }
  86
  87 QString SvnClient::diff( const svn::Path& src, const svn::Revision& srcRev,
  88                 const svn::Path& dst, const svn::Revision& dstRev,
  89                 const bool recurse, const bool ignoreAncestry,
  90                 const bool noDiffDeleted, const bool ignoreContentType )
  91         throw (svn::ClientException)
  92 {
  93     svn::Pool pool;
  94     // null options
  95     apr_array_header_t *options = svn_cstring_split( "", "\t\r\n", false, pool );
  96
  97     svn_error_t* error;
  98
  99     const char* outfileName = 0;
 100     apr_file_t* outfile = 0;
 101     const char* errfileName = 0;
 102     apr_file_t* errfile = 0;
 103
 104     QByteArray ba = (KStandardDirs::locateLocal("tmp","")+"kdevelop_svn_diff" ).toUtf8();
 105
 106     error = svn_io_open_unique_file( &outfile, &outfileName, ba.data(), ".tmp", FALSE, pool );
 107
 108     if( error != 0 )
 109     {
 110         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 111         throw svn::ClientException( error );
 112     }
 113
 114     error = svn_io_open_unique_file( &errfile, &errfileName, ba.data(), ".tmp", FALSE, pool );
 115
 116     if( error != 0 )
 117     {
 118         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 119         throw svn::ClientException( error );
 120     }
 121
 122     error = svn_client_diff3( options,
 123                             src.c_str(), srcRev.revision(),
 124                             dst.c_str(), dstRev.revision(),
 125                             recurse, ignoreAncestry, noDiffDeleted,
 126                             ignoreContentType, "UTF-8",
 127                             outfile, errfile, m_ctxt->ctx(), pool );
 128     if ( error )
 129     {
 130         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 131         throw svn::ClientException(error);
 132     }
 133
 134     // then we reopen outfile for reading
 135     apr_status_t aprstatus = apr_file_close (outfile);
 136     if (aprstatus)
 137     {
 138       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 139       ::fail (pool, aprstatus, "failed to close '%s'", outfileName);
 140     }
 141
 142     aprstatus = apr_file_open (&outfile, outfileName, APR_READ, APR_OS_DEFAULT, pool);
 143     if (aprstatus)
 144     {
 145       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 146       ::fail (pool, aprstatus, "failed to open '%s'", outfileName);
 147     }
 148
 149
 150     svn_stringbuf_t* stringbuf;
 151     // now we can read the diff output from outfile and return that
 152     error = svn_stringbuf_from_aprfile (&stringbuf, outfile, pool);
 153
 154     if (error != NULL)
 155     {
 156       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 157       throw svn::ClientException (error);
 158     }
 159
 160     ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 161     return QString::fromUtf8( stringbuf->data );
 162 }
 163
 164 QString SvnClient::diff( const svn::Path& src, const svn::Revision& pegRev,
 165                 const svn::Revision& srcRev, const svn::Revision& dstRev,
 166                 const bool recurse, const bool ignoreAncestry,
 167                 const bool noDiffDeleted, const bool ignoreContentType )
 168         throw (svn::ClientException)
 169 {
 170     svn::Pool pool;
 171     // null options
 172     apr_array_header_t *options = svn_cstring_split( "", "\t\r\n", false, pool );
 173
 174
 175     svn_error_t* error;
 176
 177     const char* outfileName = 0;
 178     apr_file_t* outfile = 0;
 179     const char* errfileName = 0;
 180     apr_file_t* errfile = 0;
 181
 182     QByteArray ba = KStandardDirs::locateLocal("tmp","").toUtf8();
 183
 184     error = svn_io_open_unique_file( &outfile, &outfileName, ba.data(), ".tmp", FALSE, pool );
 185
 186     if( error != 0 )
 187     {
 188         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 189         throw svn::ClientException( error );
 190     }
 191
 192     error = svn_io_open_unique_file( &errfile, &errfileName, ba.data(), ".tmp", FALSE, pool );
 193
 194     if( error != 0 )
 195     {
 196         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 197         throw svn::ClientException( error );
 198     }
 199
 200     error = svn_client_diff_peg3( options,
 201                             src.c_str(), pegRev.revision(),
 202                             srcRev.revision(), dstRev.revision(),
 203                             recurse, ignoreAncestry, noDiffDeleted,
 204                             ignoreContentType, "UTF-8",
 205                             outfile, errfile, m_ctxt->ctx(), pool );
 206     if ( error )
 207     {
 208         ::cleanup( outfile, outfileName, errfile, errfileName, pool );
 209         throw svn::ClientException(error);
 210     }
 211
 212     // then we reopen outfile for reading
 213     apr_status_t aprstatus = apr_file_close (outfile);
 214     if (aprstatus)
 215     {
 216       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 217       ::fail (pool, aprstatus, "failed to close '%s'", outfileName);
 218     }
 219
 220     aprstatus = apr_file_open (&outfile, outfileName, APR_READ, APR_OS_DEFAULT, pool);
 221     if (aprstatus)
 222     {
 223       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 224       ::fail (pool, aprstatus, "failed to open '%s'", outfileName);
 225     }
 226
 227
 228     svn_stringbuf_t* stringbuf;
 229     // now we can read the diff output from outfile and return that
 230     error = svn_stringbuf_from_aprfile (&stringbuf, outfile, pool);
 231
 232     if (error != NULL)
 233     {
 234       ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 235       throw svn::ClientException(error);
 236     }
 237
 238     ::cleanup (outfile, outfileName, errfile, errfileName, pool);
 239     return QString::fromUtf8( stringbuf->data );
 240 }
 241
 242 static svn_error_t *
 243 kdev_logReceiver (void *baton,
 244                 apr_hash_t * changedPaths,
 245                 svn_revnum_t rev,
 246                 const char *author,
 247                 const char *date,
 248                 const char *msg,
 249                 apr_pool_t * pool)
 250 {
 251     SvnClient* client = (SvnClient *) baton;
 252
 253     KDevelop::VcsEvent ev;
 254     ev.setAuthor( QString::fromUtf8( author ) );
 255     ev.setDate( QDateTime::fromString( QString::fromUtf8( date ), Qt::ISODate ) );
 256     ev.setMessage( QString::fromUtf8( msg ) );
 257     KDevelop::VcsRevision vcsrev;
 258     vcsrev.setRevisionValue( QVariant( qlonglong( rev ) ), KDevelop::VcsRevision::GlobalNumber );
 259     ev.setRevision( vcsrev );
 260
 261     if (changedPaths != NULL)
 262     {
 263         for (apr_hash_index_t *hi = apr_hash_first (pool, changedPaths);
 264             hi != NULL;
 265             hi = apr_hash_next (hi))
 266         {
 267             char *path;
 268             void *val;
 269             apr_hash_this (hi, (const void **)&path, NULL, &val);
 270
 271             svn_log_changed_path_t *log_item = reinterpret_cast<svn_log_changed_path_t *> (val);
 272             KDevelop::VcsItemEvent iev;
 273             iev.setRepositoryLocation( QString::fromUtf8( path ) );
 274             iev.setRepositoryCopySourceLocation( QString::fromUtf8( log_item->copyfrom_path ) );
 275             KDevelop::VcsRevision irev;
 276             irev.setRevisionValue( QVariant( qlonglong( log_item->copyfrom_rev ) ),
 277                                    KDevelop::VcsRevision::GlobalNumber );
 278             iev.setRepositoryCopySourceRevision( irev );
 279             iev.setRevision( vcsrev );
 280             switch( log_item->action )
 281             {
 282                 case 'A':
 283                     iev.setActions( KDevelop::VcsItemEvent::Added );
 284                     break;
 285                 case 'M':
 286                     iev.setActions( KDevelop::VcsItemEvent::Modified  );
 287                     break;
 288                 case 'D':
 289                     iev.setActions( KDevelop::VcsItemEvent::Deleted );
 290                     break;
 291                 case 'R':
 292                     iev.setActions( KDevelop::VcsItemEvent::Replaced );
 293                     break;
 294             }
 295             ev.setActions( ev.actions() | iev.actions() );
 296             ev.items().append( iev );
 297         }
 298     }
 299     client->emitLogEventReceived( ev );
 300
 301     return NULL;
 302 }
 303
 304 void SvnClient::log( const char* path,
 305                      const svn::Revision& start,
 306                      const svn::Revision& end,
 307                      int limit,
 308                      bool discoverChangedPaths,
 309                      bool strictNodeHistory )
 310         throw (svn::ClientException)
 311 {
 312     svn::Pool pool;
 313     svn::Targets target(path);
 314     svn_error_t *error;
 315
 316     error = svn_client_log2 (
 317     target.array(pool),
 318     start.revision(),
 319     end.revision(),
 320     limit,
 321     discoverChangedPaths ? 1 : 0,
 322     strictNodeHistory ? 1 : 0,
 323     kdev_logReceiver,
 324     this,
 325     m_ctxt->ctx(), // client ctx
 326     pool);
 327
 328     if (error != NULL)
 329     {
 330         throw svn::ClientException (error);
 331     }
 332 }
 333
 334 static svn_error_t *
 335 kdev_annotateReceiver ( void *baton,
 336                     apr_int64_t line_no,
 337                     svn_revnum_t revision,
 338                     const char *author,
 339                     const char *date,
 340                     const char *line,
 341                     apr_pool_t *pool )
 342 {
 343     Q_UNUSED(pool);
 344     SvnClient* client = reinterpret_cast<SvnClient*>(baton);
 345
 346     KDevelop::VcsAnnotationLine vcsline;
 347     vcsline.setAuthor( QString::fromUtf8( author ) );
 348     vcsline.setDate( QDateTime::fromString( QString::fromUtf8( date ), Qt::ISODate ) );
 349     vcsline.setText( QString::fromUtf8( line ) );
 350     KDevelop::VcsRevision rev;
 351     rev.setRevisionValue( QVariant( qlonglong( revision ) ), KDevelop::VcsRevision::GlobalNumber );
 352     vcsline.setRevision( rev );
 353     vcsline.setLineNumber( line_no );
 354     client->emitLineReceived( vcsline );
 355     return NULL;
 356 }
 357
 358 void SvnClient::blame( const svn::Path& path, const svn::Revision& start, const svn::Revision& end )
 359 {
 360     svn::Pool pool;
 361     svn_error_t *error;
 362     error = svn_client_blame (
 363         path.c_str (),
 364         start.revision (),
 365         end.revision (),
 366         kdev_annotateReceiver,
 367         this,
 368         m_ctxt->ctx(), // client ctx
 369         pool);
 370
 371     if (error != NULL)
 372     {
 373       throw svn::ClientException (error);
 374     }
 375
 376 }
 377
 378 void SvnClient::emitLineReceived( const KDevelop::VcsAnnotationLine& line )
 379 {
 380     emit lineReceived( line );
 381 }
 382
 383 void SvnClient::emitLogEventReceived( const KDevelop::VcsEvent& ev )
 384 {
 385     emit logEventReceived( ev );
 386 }