git.notmuchmail.org Git - notmuch/blob - bindings/ruby/message.c

   1 /* The Ruby interface to the notmuch mail library
   2  *
   3  * Copyright © 2010, 2011 Ali Polatel
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (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, see https://www.gnu.org/licenses/ .
  17  *
  18  * Author: Ali Polatel <alip@exherbo.org>
  19  */
  20
  21 #include "defs.h"
  22
  23 /*
  24  * call-seq: MESSAGE.destroy! => nil
  25  *
  26  * Destroys the message, freeing all resources allocated for it.
  27  */
  28 VALUE
  29 notmuch_rb_message_destroy (VALUE self)
  30 {
  31     notmuch_message_t *message;
  32
  33     Data_Get_Notmuch_Message (self, message);
  34
  35     notmuch_message_destroy (message);
  36     DATA_PTR (self) = NULL;
  37
  38     return Qnil;
  39 }
  40
  41 /*
  42  * call-seq: MESSAGE.message_id => String
  43  *
  44  * Get the message ID of 'message'.
  45  */
  46 VALUE
  47 notmuch_rb_message_get_message_id (VALUE self)
  48 {
  49     const char *msgid;
  50     notmuch_message_t *message;
  51
  52     Data_Get_Notmuch_Message (self, message);
  53
  54     msgid = notmuch_message_get_message_id (message);
  55
  56     return rb_str_new2 (msgid);
  57 }
  58
  59 /*
  60  * call-seq: MESSAGE.thread_id => String
  61  *
  62  * Get the thread ID of 'message'.
  63  */
  64 VALUE
  65 notmuch_rb_message_get_thread_id (VALUE self)
  66 {
  67     const char *tid;
  68     notmuch_message_t *message;
  69
  70     Data_Get_Notmuch_Message (self, message);
  71
  72     tid = notmuch_message_get_thread_id (message);
  73
  74     return rb_str_new2 (tid);
  75 }
  76
  77 /*
  78  * call-seq: MESSAGE.replies => MESSAGES
  79  *
  80  * Get a Notmuch::Messages enumerable for all of the replies to 'message'.
  81  */
  82 VALUE
  83 notmuch_rb_message_get_replies (VALUE self)
  84 {
  85     notmuch_messages_t *messages;
  86     notmuch_message_t *message;
  87
  88     Data_Get_Notmuch_Message (self, message);
  89
  90     messages = notmuch_message_get_replies (message);
  91
  92     return Data_Wrap_Struct (notmuch_rb_cMessages, NULL, NULL, messages);
  93 }
  94
  95 /*
  96  * call-seq: MESSAGE.filename => String
  97  *
  98  * Get a filename for the email corresponding to 'message'
  99  */
 100 VALUE
 101 notmuch_rb_message_get_filename (VALUE self)
 102 {
 103     const char *fname;
 104     notmuch_message_t *message;
 105
 106     Data_Get_Notmuch_Message (self, message);
 107
 108     fname = notmuch_message_get_filename (message);
 109
 110     return rb_str_new2 (fname);
 111 }
 112
 113 /*
 114  * call-seq: MESSAGE.filenames => FILENAMES
 115  *
 116  * Get all filenames for the email corresponding to MESSAGE.
 117  */
 118 VALUE
 119 notmuch_rb_message_get_filenames (VALUE self)
 120 {
 121     notmuch_filenames_t *fnames;
 122     notmuch_message_t *message;
 123
 124     Data_Get_Notmuch_Message (self, message);
 125
 126     fnames = notmuch_message_get_filenames (message);
 127
 128     return Data_Wrap_Struct (notmuch_rb_cFileNames, NULL, NULL, fnames);
 129 }
 130
 131 /*
 132  * call-seq: MESSAGE.get_flag (flag) => true or false
 133  *
 134  * Get a value of a flag for the email corresponding to 'message'
 135  */
 136 VALUE
 137 notmuch_rb_message_get_flag (VALUE self, VALUE flagv)
 138 {
 139     notmuch_message_t *message;
 140
 141     Data_Get_Notmuch_Message (self, message);
 142
 143     if (!FIXNUM_P (flagv))
 144         rb_raise (rb_eTypeError, "Flag not a Fixnum");
 145
 146     return notmuch_message_get_flag (message, FIX2INT (flagv)) ? Qtrue : Qfalse;
 147 }
 148
 149 /*
 150  * call-seq: MESSAGE.set_flag (flag, value) => nil
 151  *
 152  * Set a value of a flag for the email corresponding to 'message'
 153  */
 154 VALUE
 155 notmuch_rb_message_set_flag (VALUE self, VALUE flagv, VALUE valuev)
 156 {
 157     notmuch_message_t *message;
 158
 159     Data_Get_Notmuch_Message (self, message);
 160
 161     if (!FIXNUM_P (flagv))
 162         rb_raise (rb_eTypeError, "Flag not a Fixnum");
 163
 164     notmuch_message_set_flag (message, FIX2INT (flagv), RTEST (valuev));
 165
 166     return Qnil;
 167 }
 168
 169 /*
 170  * call-seq: MESSAGE.date => Fixnum
 171  *
 172  * Get the date of 'message'
 173  */
 174 VALUE
 175 notmuch_rb_message_get_date (VALUE self)
 176 {
 177     notmuch_message_t *message;
 178
 179     Data_Get_Notmuch_Message (self, message);
 180
 181     return UINT2NUM (notmuch_message_get_date (message));
 182 }
 183
 184 /*
 185  * call-seq: MESSAGE.header (name) => String
 186  *
 187  * Get the value of the specified header from 'message'
 188  */
 189 VALUE
 190 notmuch_rb_message_get_header (VALUE self, VALUE headerv)
 191 {
 192     const char *header, *value;
 193     notmuch_message_t *message;
 194
 195     Data_Get_Notmuch_Message (self, message);
 196
 197     SafeStringValue (headerv);
 198     header = RSTRING_PTR (headerv);
 199
 200     value = notmuch_message_get_header (message, header);
 201     if (!value)
 202         rb_raise (notmuch_rb_eMemoryError, "Out of memory");
 203
 204     return rb_str_new2 (value);
 205 }
 206
 207 /*
 208  * call-seq: MESSAGE.tags => TAGS
 209  *
 210  * Get a Notmuch::Tags enumerable for all of the tags of 'message'.
 211  */
 212 VALUE
 213 notmuch_rb_message_get_tags (VALUE self)
 214 {
 215     notmuch_message_t *message;
 216     notmuch_tags_t *tags;
 217
 218     Data_Get_Notmuch_Message (self, message);
 219
 220     tags = notmuch_message_get_tags (message);
 221     if (!tags)
 222         rb_raise (notmuch_rb_eMemoryError, "Out of memory");
 223
 224     return Data_Wrap_Struct (notmuch_rb_cTags, NULL, NULL, tags);
 225 }
 226
 227 /*
 228  * call-seq: MESSAGE.add_tag (tag) => true
 229  *
 230  * Add a tag to the 'message'
 231  */
 232 VALUE
 233 notmuch_rb_message_add_tag (VALUE self, VALUE tagv)
 234 {
 235     const char *tag;
 236     notmuch_status_t ret;
 237     notmuch_message_t *message;
 238
 239     Data_Get_Notmuch_Message (self, message);
 240
 241     SafeStringValue (tagv);
 242     tag = RSTRING_PTR (tagv);
 243
 244     ret = notmuch_message_add_tag (message, tag);
 245     notmuch_rb_status_raise (ret);
 246
 247     return Qtrue;
 248 }
 249
 250 /*
 251  * call-seq: MESSAGE.remove_tag (tag) => true
 252  *
 253  * Remove a tag from the 'message'
 254  */
 255 VALUE
 256 notmuch_rb_message_remove_tag (VALUE self, VALUE tagv)
 257 {
 258     const char *tag;
 259     notmuch_status_t ret;
 260     notmuch_message_t *message;
 261
 262     Data_Get_Notmuch_Message (self, message);
 263
 264     SafeStringValue (tagv);
 265     tag = RSTRING_PTR (tagv);
 266
 267     ret = notmuch_message_remove_tag (message, tag);
 268     notmuch_rb_status_raise (ret);
 269
 270     return Qtrue;
 271 }
 272
 273 /*
 274  * call-seq: MESSAGE.remove_all_tags => true
 275  *
 276  * Remove all tags of the 'message'
 277  */
 278 VALUE
 279 notmuch_rb_message_remove_all_tags (VALUE self)
 280 {
 281     notmuch_status_t ret;
 282     notmuch_message_t *message;
 283
 284     Data_Get_Notmuch_Message (self, message);
 285
 286     ret = notmuch_message_remove_all_tags (message);
 287     notmuch_rb_status_raise (ret);
 288
 289     return Qtrue;
 290 }
 291
 292 /*
 293  * call-seq: MESSAGE.maildir_flags_to_tags => true
 294  *
 295  * Add/remove tags according to maildir flags in the message filename (s)
 296  */
 297 VALUE
 298 notmuch_rb_message_maildir_flags_to_tags (VALUE self)
 299 {
 300     notmuch_status_t ret;
 301     notmuch_message_t *message;
 302
 303     Data_Get_Notmuch_Message (self, message);
 304
 305     ret = notmuch_message_maildir_flags_to_tags (message);
 306     notmuch_rb_status_raise (ret);
 307
 308     return Qtrue;
 309 }
 310
 311 /*
 312  * call-seq: MESSAGE.tags_to_maildir_flags => true
 313  *
 314  * Rename message filename (s) to encode tags as maildir flags
 315  */
 316 VALUE
 317 notmuch_rb_message_tags_to_maildir_flags (VALUE self)
 318 {
 319     notmuch_status_t ret;
 320     notmuch_message_t *message;
 321
 322     Data_Get_Notmuch_Message (self, message);
 323
 324     ret = notmuch_message_tags_to_maildir_flags (message);
 325     notmuch_rb_status_raise (ret);
 326
 327     return Qtrue;
 328 }
 329
 330 /*
 331  * call-seq: MESSAGE.freeze => true
 332  *
 333  * Freeze the 'message'
 334  */
 335 VALUE
 336 notmuch_rb_message_freeze (VALUE self)
 337 {
 338     notmuch_status_t ret;
 339     notmuch_message_t *message;
 340
 341     Data_Get_Notmuch_Message (self, message);
 342
 343     ret = notmuch_message_freeze (message);
 344     notmuch_rb_status_raise (ret);
 345
 346     return Qtrue;
 347 }
 348
 349 /*
 350  * call-seq: MESSAGE.thaw => true
 351  *
 352  * Thaw a 'message'
 353  */
 354 VALUE
 355 notmuch_rb_message_thaw (VALUE self)
 356 {
 357     notmuch_status_t ret;
 358     notmuch_message_t *message;
 359
 360     Data_Get_Notmuch_Message (self, message);
 361
 362     ret = notmuch_message_thaw (message);
 363     notmuch_rb_status_raise (ret);
 364
 365     return Qtrue;
 366 }