libgiggle/giggle-remote.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Imendio AB
   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 as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * 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 GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <glib.h>
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <glib/gstdio.h>
  26
  27 #include "giggle-remote.h"
  28
  29 typedef struct GiggleRemotePriv GiggleRemotePriv;
  30
  31 struct GiggleRemotePriv {
  32         gchar *name;
  33         gchar *url;
  34
  35         GList *branches; // of GiggleRemoteBranch
  36 };
  37
  38 enum {
  39         PROP_0,
  40         PROP_BRANCHES,
  41         PROP_NAME,
  42         PROP_URL
  43 };
  44
  45 static void     remote_finalize            (GObject           *object);
  46 static void     remote_get_property        (GObject           *object,
  47                                            guint              param_id,
  48                                            GValue            *value,
  49                                            GParamSpec        *pspec);
  50 static void     remote_set_property        (GObject           *object,
  51                                            guint              param_id,
  52                                            const GValue      *value,
  53                                            GParamSpec        *pspec);
  54
  55 G_DEFINE_TYPE (GiggleRemote, giggle_remote, G_TYPE_OBJECT)
  56
  57 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIGGLE_TYPE_REMOTE, GiggleRemotePriv))
  58
  59 static void
  60 giggle_remote_class_init (GiggleRemoteClass *class)
  61 {
  62         GObjectClass *object_class = G_OBJECT_CLASS (class);
  63
  64         object_class->finalize     = remote_finalize;
  65         object_class->get_property = remote_get_property;
  66         object_class->set_property = remote_set_property;
  67
  68         g_object_class_install_property (object_class,
  69                                          PROP_BRANCHES,
  70                                          g_param_spec_pointer ("branches", "Branches",
  71                                                                "The list of remote branches",
  72                                                                G_PARAM_READABLE));
  73         g_object_class_install_property (object_class,
  74                                          PROP_NAME,
  75                                          g_param_spec_string ("name", "Name",
  76                                                               "This remote's name",
  77                                                               NULL, G_PARAM_READWRITE));
  78         g_object_class_install_property (object_class,
  79                                          PROP_URL,
  80                                          g_param_spec_string ("url", "URL",
  81                                                               "This remote's URL",
  82                                                               NULL, G_PARAM_READWRITE));
  83
  84         g_type_class_add_private (object_class, sizeof (GiggleRemotePriv));
  85 }
  86
  87 static void
  88 giggle_remote_init (GiggleRemote *remote)
  89 {
  90         GiggleRemotePriv *priv;
  91
  92         priv = GET_PRIV (remote);
  93 }
  94
  95 static void
  96 remote_finalize (GObject *object)
  97 {
  98         GiggleRemotePriv *priv;
  99
 100         priv = GET_PRIV (object);
 101
 102         g_free (priv->name);
 103         g_free (priv->url);
 104
 105         giggle_remote_remove_branches (GIGGLE_REMOTE (object));
 106
 107         G_OBJECT_CLASS (giggle_remote_parent_class)->finalize (object);
 108 }
 109
 110 static void
 111 remote_get_property (GObject    *object,
 112                     guint       param_id,
 113                     GValue     *value,
 114                     GParamSpec *pspec)
 115 {
 116         GiggleRemotePriv *priv;
 117
 118         priv = GET_PRIV (object);
 119
 120         switch (param_id) {
 121         case PROP_BRANCHES:
 122                 g_value_set_pointer (value, priv->branches);
 123                 break;
 124         case PROP_NAME:
 125                 g_value_set_string (value, priv->name);
 126                 break;
 127         case PROP_URL:
 128                 g_value_set_string (value, priv->url);
 129                 break;
 130         default:
 131                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 132                 break;
 133         }
 134 }
 135
 136 static void
 137 remote_set_property (GObject      *object,
 138                     guint         param_id,
 139                     const GValue *value,
 140                     GParamSpec   *pspec)
 141 {
 142         GiggleRemotePriv *priv;
 143
 144         priv = GET_PRIV (object);
 145
 146         switch (param_id) {
 147         case PROP_NAME:
 148                 giggle_remote_set_name (GIGGLE_REMOTE (object), g_value_get_string (value));
 149                 break;
 150         case PROP_URL:
 151                 giggle_remote_set_url (GIGGLE_REMOTE (object), g_value_get_string (value));
 152                 break;
 153         default:
 154                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 155                 break;
 156         }
 157 }
 158
 159 GiggleRemote *
 160 giggle_remote_new (gchar const *name)
 161 {
 162         return g_object_new (GIGGLE_TYPE_REMOTE, "name", name, NULL);
 163 }
 164
 165 void
 166 giggle_remote_add_branch (GiggleRemote       *remote,
 167                           GiggleRemoteBranch *branch)
 168 {
 169         GiggleRemotePriv *priv;
 170
 171         priv = GET_PRIV (remote);
 172
 173         priv->branches = g_list_append (priv->branches, g_object_ref (branch));
 174         g_object_notify (G_OBJECT (remote), "branches");
 175 }
 176
 177 GiggleRemote *
 178 giggle_remote_new_from_file (gchar const *filename)
 179 {
 180         GiggleRemote *remote;
 181         gchar        *content;
 182
 183         content = g_path_get_basename (filename);
 184         remote = giggle_remote_new (content);
 185         g_free (content);
 186         content = NULL;
 187
 188         if(g_file_get_contents (filename, &content, NULL, NULL)) {
 189                 gchar**lines;
 190                 gchar**step;
 191                 lines = g_strsplit (content, "\n", -1);
 192                 for (step = lines; step && *step; step++) {
 193                         GiggleRemoteBranch* branch = NULL;
 194                         if(!**step) {
 195                                 /* empty string */
 196                                 continue;
 197                         } else if(g_str_has_prefix(*step, "URL: ")) {
 198                                 giggle_remote_set_url (remote, *step + strlen ("URL: "));
 199                         } else if(g_str_has_prefix(*step, "Push: ")) {
 200                                 branch = giggle_remote_branch_new (GIGGLE_REMOTE_DIRECTION_PUSH,
 201                                                                    *step + strlen ("Push: "));
 202                         } else if(g_str_has_prefix(*step, "Pull: ")) {
 203                                 branch = giggle_remote_branch_new (GIGGLE_REMOTE_DIRECTION_PULL,
 204                                                                    *step + strlen ("Pull: "));
 205                         } else {
 206                                 gchar* escaped = g_strescape (*step, NULL);
 207                                 g_warning ("Read unexpected line at %s:%td\n\"%s\"",
 208                                            filename, step - lines, escaped);
 209                                 g_free (escaped);
 210                         }
 211
 212                         if(GIGGLE_IS_REMOTE_BRANCH (branch)) {
 213                                 giggle_remote_add_branch (remote, branch);
 214                                 g_object_unref (branch);
 215                                 branch = NULL;
 216                         }
 217                 }
 218                 g_strfreev (lines);
 219         }
 220         g_free (content);
 221
 222         return remote;
 223 }
 224
 225 GList *
 226 giggle_remote_get_branches (GiggleRemote *remote)
 227 {
 228         g_return_val_if_fail (GIGGLE_IS_REMOTE (remote), NULL);
 229
 230         return GET_PRIV (remote)->branches;
 231 }
 232
 233 void
 234 giggle_remote_remove_branches (GiggleRemote *self)
 235 {
 236         GiggleRemotePriv *priv;
 237
 238         g_return_if_fail (GIGGLE_IS_REMOTE (self));
 239
 240         priv = GET_PRIV (self);
 241
 242         g_list_foreach (priv->branches, (GFunc)g_object_unref, NULL);
 243         g_list_free (priv->branches);
 244         priv->branches = NULL;
 245         g_object_notify (G_OBJECT (self), "branches");
 246 }
 247
 248 const gchar *
 249 giggle_remote_get_name (GiggleRemote *remote)
 250 {
 251         g_return_val_if_fail (GIGGLE_IS_REMOTE (remote), NULL);
 252
 253         return GET_PRIV (remote)->name;
 254 }
 255
 256 void
 257 giggle_remote_set_name (GiggleRemote *self,
 258                         gchar const  *name)
 259 {
 260         GiggleRemotePriv *priv;
 261
 262         g_return_if_fail (GIGGLE_IS_REMOTE (self));
 263         g_return_if_fail (name && *name);
 264
 265         priv = GET_PRIV (self);
 266
 267         if (name == priv->name) {
 268                 return;
 269         }
 270
 271         g_free (priv->name);
 272         priv->name = g_strdup (name);
 273
 274         g_object_notify (G_OBJECT (self), "name");
 275 }
 276
 277 const gchar *
 278 giggle_remote_get_url (GiggleRemote *remote)
 279 {
 280         g_return_val_if_fail (GIGGLE_IS_REMOTE (remote), NULL);
 281
 282         return GET_PRIV (remote)->url;
 283 }
 284
 285 void
 286 giggle_remote_set_url (GiggleRemote *remote,
 287                        const gchar  *url)
 288 {
 289         GiggleRemotePriv *priv;
 290
 291         g_return_if_fail (GIGGLE_IS_REMOTE (remote));
 292         priv = GET_PRIV (remote);
 293
 294         if(priv->url == url) {
 295                 return;
 296         }
 297
 298         g_free (priv->url);
 299         priv->url = g_strdup (url);
 300
 301         g_object_notify (G_OBJECT (remote), "url");
 302 }
 303
 304 void
 305 giggle_remote_save_to_file (GiggleRemote *self,
 306                             gchar const  *filename)
 307 {
 308         GList            *branches;
 309         FILE             *file;
 310
 311         g_return_if_fail (GIGGLE_IS_REMOTE (self));
 312
 313         file = g_fopen (filename, "w");
 314
 315         g_return_if_fail (file);
 316
 317         /* "URL: kenny.imendio.com:/var/git/public/sven/giggle.git" */
 318         fprintf (file, "URL: %s\n", giggle_remote_get_url (self));
 319
 320         for (branches = giggle_remote_get_branches (self); branches; branches = g_list_next (branches)) {
 321                 /* "Pull: refs/heads/master:refs/heads/origin" */
 322                 gchar const* direction;
 323
 324                 switch(giggle_remote_branch_get_direction (branches->data)) {
 325                 case GIGGLE_REMOTE_DIRECTION_PULL:
 326                         direction = "Pull";
 327                         break;
 328                 case GIGGLE_REMOTE_DIRECTION_PUSH:
 329                         direction = "Push";
 330                         break;
 331                 default:
 332                         g_warning ("Got unexpected remote direction: %d",
 333                                    giggle_remote_branch_get_direction (branches->data));
 334                         direction = "";
 335                         break;
 336                 }
 337
 338                 fprintf (file, "%s: %s\n", direction,
 339                          giggle_remote_branch_get_refspec (branches->data));
 340         }
 341         fclose (file);
 342 }