plugins/cvs-plugin/cvs-interface.c

   1 /*
   2  * cvs-interface.c (c) 2005 Johannes Schmid
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU Library General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  */
  17
  18 #include <libanjuta/anjuta-debug.h>
  19
  20
  21 #include <libgnomevfs/gnome-vfs.h>
  22 #include "cvs-execute.h"
  23 #include "cvs-callbacks.h"
  24 #include "cvs-interface.h"
  25 #include "plugin.h"
  26 #include "libgen.h"
  27
  28 static gchar* create_cvs_command_with_cvsroot(AnjutaPreferences* prefs,
  29                                                                 const gchar* action,
  30                                                                 const gchar* command_options,
  31                                                                 const gchar* command_arguments,
  32                                                                 const gchar* cvsroot)
  33 {
  34         gchar* cvs;
  35         gchar* global_options = NULL;
  36         gboolean ignorerc;
  37         gint compression;
  38         gchar* command;
  39         /* command global_options cvsroot action command_options command_arguments */
  40         gchar* CVS_FORMAT = "%s %s %s %s %s %s";
  41
  42         g_return_val_if_fail (prefs != NULL, NULL);
  43         g_return_val_if_fail (action != NULL, NULL);
  44         g_return_val_if_fail (command_options != NULL, NULL);
  45         g_return_val_if_fail (command_arguments != NULL, NULL);
  46
  47         cvs = anjuta_preferences_get(prefs, "cvs.path");
  48         compression = anjuta_preferences_get_int(prefs, "cvs.compression");
  49         ignorerc = anjuta_preferences_get_int(prefs, "cvs.ignorerc");
  50         if (compression && ignorerc)
  51                 global_options = g_strdup_printf("-f -z%d", compression);
  52         else if (compression)
  53                 global_options = g_strdup_printf("-z%d", compression);
  54         else if (ignorerc)
  55                 global_options = g_strdup("-f");
  56         else
  57                 global_options = g_strdup("");
  58         if (cvsroot == NULL)
  59         {
  60                 cvsroot = "";
  61         }
  62         command = g_strdup_printf(CVS_FORMAT, cvs, global_options, cvsroot, action,
  63                                                                 command_options, command_arguments);
  64         g_free (cvs);
  65         g_free (global_options);
  66
  67         return command;
  68 }
  69
  70 inline static gchar* create_cvs_command(AnjutaPreferences* prefs,
  71                                                                 const gchar* action,
  72                                                                 const gchar* command_options,
  73                                                                 const gchar* command_arguments)
  74 {
  75         return create_cvs_command_with_cvsroot(prefs, action, command_options,
  76                 command_arguments, NULL);
  77 }
  78
  79 static void add_option(gboolean value, GString* options, const gchar* argument)
  80 {
  81         if (value)
  82         {
  83                         g_string_append(options, " ");
  84                         g_string_append(options, argument);
  85         }
  86 }
  87
  88 static gboolean is_directory(const gchar* filename)
  89 {
  90         GnomeVFSFileInfo info;
  91         GnomeVFSResult result;
  92
  93         result = gnome_vfs_get_file_info(filename, &info, GNOME_VFS_FILE_INFO_DEFAULT);
  94         if (result == GNOME_VFS_OK)
  95         {
  96                 if (info.type == GNOME_VFS_FILE_TYPE_DIRECTORY)
  97                         return TRUE;
  98                 else
  99                         return FALSE;
 100         }
 101         else
 102                 return FALSE;
 103 }
 104
 105 void anjuta_cvs_add (AnjutaPlugin *obj, const gchar* filename,
 106         gboolean binary, GError **err)
 107 {
 108         gchar* command;
 109         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 110         GString* options = g_string_new("");
 111         gchar* file = g_strdup(filename);
 112
 113         add_option(binary, options, "-kb");
 114
 115
 116         command = create_cvs_command(
 117                 anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 118                 NULL), "add", options->str, basename(file));
 119
 120         cvs_execute(plugin, command, dirname(file));
 121         g_free(command);
 122         g_free(file);
 123         g_string_free(options, TRUE);
 124 }
 125
 126 void anjuta_cvs_commit (AnjutaPlugin *obj, const gchar* filename, const gchar* log,
 127         const gchar* rev, gboolean recurse, GError **err)
 128 {
 129         GString* options = g_string_new("");
 130         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 131         gchar* command;
 132
 133         if (strlen(log))
 134                 g_string_printf(options, "-m '%s'", log);
 135         else
 136                 g_string_printf(options, "-m 'no log message'");
 137
 138         if (strlen(rev))
 139         {
 140                 g_string_append_printf(options, " -r %s", rev);
 141         }
 142         add_option(!recurse, options, "-l");
 143
 144         if (!is_directory(filename))
 145         {
 146                 gchar* file = g_strdup(filename);
 147                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 148                         NULL), "commit", options->str, basename(file));
 149                 cvs_execute(plugin, command, dirname(file));
 150                 g_free(file);
 151         }
 152         else
 153         {
 154                 gchar* dir = g_strdup(filename);
 155                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 156                         NULL), "commit", options->str, "");
 157                 cvs_execute(plugin, command, dir);
 158                 g_free(dir);
 159         }
 160         g_free(command);
 161         g_string_free(options, TRUE);
 162 }
 163
 164 void anjuta_cvs_diff (AnjutaPlugin *obj, const gchar* filename, const gchar* rev,
 165         gboolean recurse, gboolean patch_style, gboolean unified, GError **err)
 166 {
 167         GString* options = g_string_new("");
 168         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 169         gchar* command;
 170
 171         if (strlen(rev))
 172         {
 173                 g_string_append_printf(options, " -r %s", rev);
 174         }
 175         add_option(!recurse, options, "-l");
 176         add_option(unified, options, "-u");
 177
 178         if (!is_directory(filename))
 179         {
 180                 gchar* file = g_strdup(filename);
 181                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 182                                                                  NULL), "diff", options->str, basename(file));
 183                 cvs_execute_diff(plugin, command, dirname(file));
 184         }
 185         else
 186         {
 187                 gchar* dir = g_strdup(filename);
 188                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 189                                                                  NULL), "diff", options->str, "");
 190                 cvs_execute_diff(plugin, command, dir);
 191                 g_free(dir);
 192         }
 193         g_free(command);
 194         g_string_free(options, TRUE);
 195 }
 196
 197 void anjuta_cvs_log (AnjutaPlugin *obj, const gchar* filename, gboolean recurse, gboolean verbose, GError **err)
 198 {
 199         GString* options = g_string_new("");
 200         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 201         gchar* command;
 202
 203         add_option(!recurse, options, "-l");
 204         add_option(!verbose, options, "-h");
 205
 206         if (!is_directory(filename))
 207         {
 208                 gchar* file = g_strdup(filename);
 209                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 210                                                                  NULL), "log", options->str, basename(file));
 211                 cvs_execute_log(plugin, command, dirname(file));
 212                 g_free(file);
 213         }
 214         else
 215         {
 216                 gchar* dir = g_strdup(filename);
 217                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 218                                                                  NULL), "log", options->str, "");
 219                 cvs_execute_log(plugin, command, dir);
 220                 g_free(dir);
 221         }
 222         g_free(command);
 223         g_string_free(options, TRUE);
 224 }
 225
 226 void anjuta_cvs_remove (AnjutaPlugin *obj, const gchar* filename, GError **err)
 227 {
 228         gchar* command;
 229         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 230         GString* options = g_string_new("");
 231         gchar* file = g_strdup(filename);
 232
 233         command = create_cvs_command(
 234                 anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 235                 NULL), "remove", options->str, basename(file));
 236
 237         cvs_execute(plugin, command, dirname(file));
 238         g_free(file);
 239         g_free(command);
 240         g_string_free(options, TRUE);
 241 }
 242
 243 void anjuta_cvs_status (AnjutaPlugin *obj, const gchar* filename, gboolean recurse, gboolean verbose, GError **err)
 244 {
 245         gchar* command;
 246         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 247         GString* options = g_string_new("");
 248
 249         add_option(!recurse, options, "-l");
 250         add_option(verbose, options, "-v");
 251
 252         if (!is_directory(filename))
 253         {
 254                 gchar* file = g_strdup(filename);
 255                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 256                                                                  NULL), "status", options->str, basename(file));
 257                 cvs_execute_status(plugin, command, dirname(file));
 258                 g_free(file);
 259         }
 260         else
 261         {
 262                 gchar* dir = g_strdup(filename);
 263                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 264                                                                  NULL), "status", options->str, "");
 265                 cvs_execute_status(plugin, command, dir);
 266                 g_free(dir);
 267         }
 268         g_free(command);
 269         g_string_free(options, TRUE);
 270 }
 271
 272 void anjuta_cvs_update (AnjutaPlugin *obj, const gchar* filename, gboolean recurse,
 273         gboolean prune, gboolean create, gboolean reset_sticky, const gchar* revision, GError **err)
 274 {
 275         GString* options = g_string_new("");
 276         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 277         gchar* command;
 278
 279         add_option(!recurse, options, "-l");
 280         add_option(prune, options, "-P");
 281         add_option(create, options, "-d");
 282         if (strlen(revision))
 283         {
 284                 g_string_append_printf(options, " -r %s", revision);
 285         }
 286         else
 287         {
 288                 add_option(reset_sticky, options, "-A");
 289         }
 290
 291         if (!is_directory(filename))
 292         {
 293                 gchar* file = g_strdup(filename);
 294                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 295                                                                  NULL), "update", options->str, basename(file));
 296                 cvs_execute(plugin, command, dirname(file));
 297                 g_free(file);
 298         }
 299         else
 300         {
 301                 gchar* dir = g_strdup(filename);
 302                 command = create_cvs_command(anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell,
 303                                                                  NULL), "update", options->str, "");
 304                 cvs_execute(plugin, command, dir);
 305         }
 306         g_free(command);
 307         g_string_free(options, TRUE);
 308 }
 309
 310 void anjuta_cvs_import (AnjutaPlugin *obj, const gchar* dir, const gchar* cvsroot,
 311         const gchar* module, const gchar* vendor, const gchar* release,
 312         const gchar* log, gint server_type, const gchar* username, const
 313         gchar* password, GError** error)
 314 {
 315         gchar* cvs_command;
 316         gchar* root;
 317         GString* options = g_string_new("");
 318         CVSPlugin* plugin = ANJUTA_PLUGIN_CVS (obj);
 319
 320         switch (server_type)
 321         {
 322                 case SERVER_LOCAL:
 323                 {
 324                         root = g_strdup_printf("-d %s", cvsroot);
 325                         break;
 326                 }
 327                 case SERVER_EXTERN:
 328                 {
 329                         root = g_strdup_printf("-d:ext:%s@%s", username, cvsroot);
 330                         break;
 331                 }
 332                 case SERVER_PASSWORD:
 333                 {
 334                         root = g_strdup_printf("-d:pserver:%s:%s@%s",
 335                                 username, password, cvsroot);
 336                         break;
 337                 }
 338                 default:
 339                 {
 340                         DEBUG_PRINT("Invalid cvs server type!");
 341                         g_string_free (options, TRUE);
 342                         return;
 343                 }
 344         }
 345         g_string_printf(options, "-m '%s'", log);
 346         g_string_append_printf(options, " %s %s %s", module, vendor, release);
 347
 348         cvs_command = create_cvs_command_with_cvsroot(
 349                 anjuta_shell_get_preferences (ANJUTA_PLUGIN(plugin)->shell, NULL),
 350                 "import", options->str, "", root);
 351         cvs_execute(plugin, cvs_command, dir);
 352
 353         g_string_free(options, TRUE);
 354         g_free(cvs_command);
 355 }