rbpod 0.0.5 → 0.0.6

data/ext/rbpod/track.c

@@ -1,115 +1,203 @@
 /* track.c */
 
 #include "rbpod.h"
-#include "track.h"
 
-/*
- * call-seq:
- *     transferred?() -> Boolean
- *
- * Returns true or false if this track has been transferred to the device.
- */
-static VALUE rbpod_track_transferred_p(VALUE self)
+ID sMEDIA_TYPE_AUDIO_VIDEO;
+ID sMEDIA_TYPE_AUDIO;
+ID sMEDIA_TYPE_VIDEO;
+ID sMEDIA_TYPE_PODCAST;
+ID sMEDIA_TYPE_VIDEO_PODCAST;
+ID sMEDIA_TYPE_AUDIO_BOOK;
+ID sMEDIA_TYPE_MUSIC_VIDEO;
+ID sMEDIA_TYPE_TV_SHOW_EXCL;
+ID sMEDIA_TYPE_TV_SHOW;
+
+typedef enum {
+    MEDIA_TYPE_AUDIO_VIDEO   = 0x00000000,
+    MEDIA_TYPE_AUDIO         = 0x00000001,
+    MEDIA_TYPE_VIDEO         = 0x00000002,
+    MEDIA_TYPE_PODCAST       = 0x00000004,
+    MEDIA_TYPE_VIDEO_PODCAST = 0x00000006,
+    MEDIA_TYPE_AUDIO_BOOK    = 0x00000008,
+    MEDIA_TYPE_MUSIC_VIDEO   = 0x00000020,
+    MEDIA_TYPE_TV_SHOW_EXCL  = 0x00000040,
+    MEDIA_TYPE_TV_SHOW       = 0x00000060,
+} media_type;
+
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, title);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, album);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, artist);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, genre);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, filetype);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, comment);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, category);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, composer);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, grouping);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, description);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, podcasturl);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, podcastrss);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, subtitle);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, tvshow);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, tvepisode);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, tvnetwork);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, albumartist);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, keywords);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_artist);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_title);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_album);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_albumartist);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_composer);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, STRING, sort_tvshow);
+
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, id);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, size);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, tracklen);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, cd_nr);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, cds);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, track_nr);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, tracks);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, bitrate);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, samplerate);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, year);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, volume);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, soundcheck);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, rating);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, playcount);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, recent_playcount);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, BPM);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, starttime);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, stoptime);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, skipcount);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, recent_skipcount);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, pregap);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, samplecount);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, postgap);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, season_nr);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, FIXNUM, episode_nr);
+
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, transferred);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, compilation);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, visible);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, explicit_flag);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, skip_when_shuffling);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, remember_playback_position);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, lyrics_flag);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, movie_flag);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, gapless_track_flag);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, BOOLEAN, gapless_album_flag);
+
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, time_added);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, time_modified);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, time_played);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, bookmark_time);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, time_released);
+DEF_ATTR_ACCESSOR(Itdb_Track, track, DATETIME, last_skipped);
+
+static VALUE rbpod_track_ipod_path_get(VALUE self)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return BooleanValue(track->transferred);
+    gchar *buffer = NULL;
+
+    if (track->ipod_path == NULL)
+        return Qnil;
+
+    buffer = g_strdup(track->ipod_path);
+
+    itdb_filename_ipod2fs(buffer);
+
+    return rb_str_new2(buffer);
 }
 
-/*
- * call-seq:
- *     path() -> String
- *
- * Returns the full path to the file backing this track on the device.
- */
-static VALUE rbpod_track_path_get(VALUE self)
+static VALUE rbpod_track_ipod_path_set(VALUE self, VALUE value)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    VALUE mount_point, path_parts, file_path, full_path;
-    Itdb_iTunesDB *database = track->itdb;
-    const gchar *ipod_path = NULL;
+    gchar *new_path = StringValueCStr(value);
+    gchar *buffer = NULL;
 
-    /* Never hurts to be careful, right? */
-    if (database == NULL || track->ipod_path == NULL) {
-        return Qnil;
-    }
+    if (track->ipod_path != NULL)
+        g_free(track);
+
+    buffer = g_strdup(new_path);
 
-    /* Skip the prepended directory separator. */
-    ipod_path  = (const gchar *) &track->ipod_path[1];
+    itdb_filename_fs2ipod(buffer);
 
-    /* Extract the iPod mount point from the database pointer. */
-    mount_point = rb_str_new2(itdb_get_mountpoint(database));
+    track->ipod_path = buffer;
 
-    /* Split the track's ipod_path by ':' character. */
-    path_parts = rb_str_split(rb_str_new2(ipod_path), ":");
+    return Qnil;
+}
 
-    /* Use File.join to rejoin the path safely. */
-    file_path = rb_funcall2(rb_cFile, rb_intern("join"), 1, &path_parts);
+static VALUE rbpod_track_mediatype_get(VALUE self)
+{
+    Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
 
-    /* Retrieve the expanded absolute path name. */
-    full_path = rb_file_expand_path(file_path, mount_point);
+    switch(track->mediatype) {
+        case MEDIA_TYPE_AUDIO_VIDEO:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_AUDIO_VIDEO);
+        case MEDIA_TYPE_AUDIO:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_AUDIO);
+        case MEDIA_TYPE_VIDEO:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_VIDEO);
+        case MEDIA_TYPE_PODCAST:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_PODCAST);
+        case MEDIA_TYPE_VIDEO_PODCAST:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_VIDEO_PODCAST);
+        case MEDIA_TYPE_AUDIO_BOOK:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_AUDIO_BOOK);
+        case MEDIA_TYPE_MUSIC_VIDEO:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_MUSIC_VIDEO);
+        case MEDIA_TYPE_TV_SHOW_EXCL:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_TV_SHOW_EXCL);
+        case MEDIA_TYPE_TV_SHOW:
+            return rb_const_get(cRbPodTrack, sMEDIA_TYPE_TV_SHOW);
+    }
 
-    /* Return a Pathname instance for the resolved path. */
-    return rb_class_new_instance(1, &full_path, rb_cPathname);
+    return Qnil;
 }
 
-/*
- * call-seq:
- *     type() -> String
- *
- * Returns a human-readable string describing the content of the track.
- */
-static VALUE rbpod_track_type_get(VALUE self)
+static VALUE rbpod_track_mediatype_set(VALUE self, VALUE value)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return rb_str_new2(track->filetype);
+    track->mediatype = NUM2INT(value);
+    return Qnil;
 }
 
-/*
- * call-seq:
- *     artist() -> String
- *
- * Returns the artist for the track.
- */
-static VALUE rbpod_track_artist_get(VALUE self)
+static VALUE rbpod_track_checked_get(VALUE self)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return rb_str_new2(track->artist);
+    return (track->checked == 0x0) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *     album() -> String
- *
- * Returns the album for the track.
- */
-static VALUE rbpod_track_album_get(VALUE self)
+static VALUE rbpod_track_checked_set(VALUE self, VALUE value)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return rb_str_new2(track->album);
+    track->checked = RTEST(value) ? 0x0 : 0x1;
+    return Qnil;
 }
 
-/*
- * call-seq:
- *     title() -> String
- *
- * Returns the title of the track.
- */
-static VALUE rbpod_track_title_get(VALUE self)
+static VALUE rbpod_track_has_artwork_get(VALUE self)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return rb_str_new2(track->title);
+    return (track->has_artwork == 0x01) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *     id() -> Fixnum
- *
- * Returns the internal ID number for this track. Do not use this method.
- */
-static VALUE rbpod_track_id_get(VALUE self)
+static VALUE rbpod_track_has_artwork_set(VALUE self, VALUE value)
+{
+    Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
+    track->has_artwork = RTEST(value) ? 0x1 : 0x2;
+    return Qnil;
+}
+
+static VALUE rbpod_track_mark_unplayed_get(VALUE self)
 {
     Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
-    return INT2NUM(track->id);
+    return (track->mark_unplayed == 0x2) ? Qtrue : Qfalse;
+}
+
+static VALUE rbpod_track_mark_unplayed_set(VALUE self, VALUE value)
+{
+    Itdb_Track *track = TYPED_DATA_PTR(self, Itdb_Track);
+    track->mark_unplayed = RTEST(value) ? 0x2 : 0x1;
+    return Qnil;
 }
 
 /*
@@ -128,7 +216,7 @@ static void rbpod_track_deallocate(void *handle)
     Itdb_Track *track = (Itdb_Track *) handle;
 
     /* Don't free tracks that are assigned to a playlist/database. */
-    if (track->itdb == NULL || track->id == 0) {
+    if (track->itdb == NULL) {
         itdb_track_free((Itdb_Track *) handle);
     }
 
@@ -152,15 +240,99 @@ void Init_rbpod_track(void)
 
     rb_define_method(cRbPodTrack, "initialize", rbpod_track_initialize, 0);
 
-    rb_define_private_method(cRbPodTrack, "id", rbpod_track_id_get, 0);
+    sMEDIA_TYPE_AUDIO_VIDEO   = rb_intern("MEDIA_TYPE_AUDIO_VIDEO");
+    sMEDIA_TYPE_AUDIO         = rb_intern("MEDIA_TYPE_AUDIO");
+    sMEDIA_TYPE_VIDEO         = rb_intern("MEDIA_TYPE_VIDEO");
+    sMEDIA_TYPE_PODCAST       = rb_intern("MEDIA_TYPE_PODCAST");
+    sMEDIA_TYPE_VIDEO_PODCAST = rb_intern("MEDIA_TYPE_VIDEO_PODCAST");
+    sMEDIA_TYPE_AUDIO_BOOK    = rb_intern("MEDIA_TYPE_AUDIO_BOOK");
+    sMEDIA_TYPE_MUSIC_VIDEO   = rb_intern("MEDIA_TYPE_MUSIC_VIDEO");
+    sMEDIA_TYPE_TV_SHOW_EXCL  = rb_intern("MEDIA_TYPE_TV_SHOW_EXCL");
+    sMEDIA_TYPE_TV_SHOW       = rb_intern("MEDIA_TYPE_TV_SHOW");
+
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_AUDIO_VIDEO,   UINT2NUM(MEDIA_TYPE_AUDIO_VIDEO));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_AUDIO,         UINT2NUM(MEDIA_TYPE_AUDIO));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_VIDEO,         UINT2NUM(MEDIA_TYPE_VIDEO));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_PODCAST,       UINT2NUM(MEDIA_TYPE_PODCAST));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_VIDEO_PODCAST, UINT2NUM(MEDIA_TYPE_VIDEO_PODCAST));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_AUDIO_BOOK,    UINT2NUM(MEDIA_TYPE_AUDIO_BOOK));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_MUSIC_VIDEO,   UINT2NUM(MEDIA_TYPE_MUSIC_VIDEO));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_TV_SHOW_EXCL,  UINT2NUM(MEDIA_TYPE_TV_SHOW_EXCL));
+    rb_const_set(cRbPodTrack, sMEDIA_TYPE_TV_SHOW,       UINT2NUM(MEDIA_TYPE_TV_SHOW));
+
+    DCL_ATTR(cRbPodTrack, track, title,            title);
+    DCL_ATTR(cRbPodTrack, track, ipod_path,        ipod_path);
+    DCL_ATTR(cRbPodTrack, track, album,            album);
+    DCL_ATTR(cRbPodTrack, track, artist,           artist);
+    DCL_ATTR(cRbPodTrack, track, genre,            genre);
+    DCL_ATTR(cRbPodTrack, track, file_type,        filetype);
+    DCL_ATTR(cRbPodTrack, track, comment,          comment);
+    DCL_ATTR(cRbPodTrack, track, category,         category);
+    DCL_ATTR(cRbPodTrack, track, composer,         composer);
+    DCL_ATTR(cRbPodTrack, track, grouping,         grouping);
+    DCL_ATTR(cRbPodTrack, track, description,      description);
+    DCL_ATTR(cRbPodTrack, track, podcast_url,      podcasturl);
+    DCL_ATTR(cRbPodTrack, track, podcast_rss,      podcastrss);
+    DCL_ATTR(cRbPodTrack, track, subtitle,         subtitle);
+    DCL_ATTR(cRbPodTrack, track, tv_show,          tvshow);
+    DCL_ATTR(cRbPodTrack, track, tv_episode,       tvepisode);
+    DCL_ATTR(cRbPodTrack, track, tv_network,       tvnetwork);
+    DCL_ATTR(cRbPodTrack, track, album_artist,     albumartist);
+    DCL_ATTR(cRbPodTrack, track, keywords,         keywords);
+    DCL_ATTR(cRbPodTrack, track, sort_artist,      sort_artist);
+    DCL_ATTR(cRbPodTrack, track, sort_title,       sort_title);
+    DCL_ATTR(cRbPodTrack, track, sort_album,       sort_album);
+    DCL_ATTR(cRbPodTrack, track, sort_albumartist, sort_albumartist);
+    DCL_ATTR(cRbPodTrack, track, sort_composer,    sort_composer);
+    DCL_ATTR(cRbPodTrack, track, sort_tvshow,      sort_tvshow);
+
+    DCL_ATTR(cRbPodTrack, track, id,                id);
+    DCL_ATTR(cRbPodTrack, track, size,              size);
+    DCL_ATTR(cRbPodTrack, track, length,            tracklen);
+    DCL_ATTR(cRbPodTrack, track, cd_number,         cd_nr);
+    DCL_ATTR(cRbPodTrack, track, cd_total,          cds);
+    DCL_ATTR(cRbPodTrack, track, track_number,      track_nr);
+    DCL_ATTR(cRbPodTrack, track, track_total,       tracks);
+    DCL_ATTR(cRbPodTrack, track, bitrate,           bitrate);
+    DCL_ATTR(cRbPodTrack, track, samplerate,        samplerate);
+    DCL_ATTR(cRbPodTrack, track, year,              year);
+    DCL_ATTR(cRbPodTrack, track, volume,            volume);
+    DCL_ATTR(cRbPodTrack, track, soundcheck,        soundcheck);
+    DCL_ATTR(cRbPodTrack, track, bookmark,          bookmark_time);
+    DCL_ATTR(cRbPodTrack, track, rating,            rating);
+    DCL_ATTR(cRbPodTrack, track, play_count,        playcount);
+    DCL_ATTR(cRbPodTrack, track, recent_play_count, recent_playcount);
+    DCL_ATTR(cRbPodTrack, track, BPM,               BPM);
+    DCL_ATTR(cRbPodTrack, track, start_offset,      starttime);
+    DCL_ATTR(cRbPodTrack, track, stop_offset,       stoptime);
+    DCL_ATTR(cRbPodTrack, track, skip_count,        skipcount);
+    DCL_ATTR(cRbPodTrack, track, recent_skip_count, recent_skipcount);
+    DCL_ATTR(cRbPodTrack, track, pregap,            pregap);
+    DCL_ATTR(cRbPodTrack, track, sample_count,      samplecount);
+    DCL_ATTR(cRbPodTrack, track, postgap,           postgap);
+    DCL_ATTR(cRbPodTrack, track, media_type,        mediatype);
+    DCL_ATTR(cRbPodTrack, track, season_number,     season_nr);
+    DCL_ATTR(cRbPodTrack, track, episode_number,    episode_nr);
 
-    rb_define_method(cRbPodTrack, "title", rbpod_track_title_get, 0);
-    rb_define_method(cRbPodTrack, "album", rbpod_track_album_get, 0);
-    rb_define_method(cRbPodTrack, "artist", rbpod_track_artist_get, 0);
-    rb_define_method(cRbPodTrack, "type", rbpod_track_type_get, 0);
-    rb_define_method(cRbPodTrack, "path", rbpod_track_path_get, 0);
+    DCL_ATTR_P(cRbPodTrack, track, transferred,         transferred);
+    DCL_ATTR_P(cRbPodTrack, track, compilation,         compilation);
+    DCL_ATTR_P(cRbPodTrack, track, checked,             checked);
+    DCL_ATTR_P(cRbPodTrack, track, visible,             visible);
+    DCL_ATTR_P(cRbPodTrack, track, explicit,            explicit_flag);
+    DCL_ATTR_P(cRbPodTrack, track, has_artwork,         has_artwork);
+    DCL_ATTR_P(cRbPodTrack, track, skip_when_shuffling, skip_when_shuffling);
+    DCL_ATTR_P(cRbPodTrack, track, remember_position,   remember_playback_position);
+    DCL_ATTR_P(cRbPodTrack, track, has_lyrics,          lyrics_flag);
+    DCL_ATTR_P(cRbPodTrack, track, movie,               movie_flag);
+    DCL_ATTR_P(cRbPodTrack, track, unplayed,            mark_unplayed);
+    DCL_ATTR_P(cRbPodTrack, track, gapless,             gapless_track_flag);
+    DCL_ATTR_P(cRbPodTrack, track, has_gapless_album,   gapless_album_flag);
 
-    rb_define_method(cRbPodTrack, "transferred?", rbpod_track_transferred_p, 0);
+    DCL_ATTR(cRbPodTrack, track, added_on,        time_added);
+    DCL_ATTR(cRbPodTrack, track, modified_on,     time_modified);
+    DCL_ATTR(cRbPodTrack, track, last_played_on,  time_played);
+    DCL_ATTR(cRbPodTrack, track, released_on,     time_released);
+    DCL_ATTR(cRbPodTrack, track, last_skipped_on, last_skipped);
 
     return;
 }

data/ext/rbpod/track_collection.c

@@ -1,10 +1,6 @@
 /* track_collection.c */
 
 #include "rbpod.h"
-#include "track.h"
-#include "playlist.h"
-#include "collection.h"
-#include "track_collection.h"
 
 /*
  * call-seq:
@@ -14,7 +10,103 @@
  */
 static VALUE rbpod_track_collection_playlist(VALUE self)
 {
-    return rb_iv_get(self, "@playlist");
+    VALUE playlist = rb_iv_get(self, "@playlist");
+
+    if (rb_obj_is_instance_of(playlist, cRbPodPlaylist) == FALSE) {
+        rb_raise(eRbPodError, "Invalid Arguments: Expected RbPod::Playlist, got %s", StringValueCStr(playlist));
+        return Qnil;
+    }
+
+    return playlist;
+}
+
+/*
+ * call-seq:
+ *     include?(track) -> boolean
+ *
+ * Determines if the given RbPod::Track +track+ is within this playlist.
+ */
+static VALUE rbpod_track_collection_include(VALUE self, VALUE track)
+{
+    VALUE playlist = rbpod_track_collection_playlist(self);
+    Itdb_Playlist *_playlist = TYPED_DATA_PTR(playlist, Itdb_Playlist);
+    Itdb_Track *_track = TYPED_DATA_PTR(track, Itdb_Track);
+
+    if (rb_obj_is_instance_of(track, cRbPodTrack) == FALSE) {
+        rb_raise(eRbPodError, "Invalid Arguments: Expected RbPod::Track, got %s", StringValueCStr(playlist));
+        return Qnil;
+    }
+
+    return BooleanValue(itdb_playlist_contains_track(_playlist, _track));
+}
+
+/*
+ * call-seq:
+ *     remove(track) -> nil
+ *
+ * Removes a given RbPod::Track +track+ from the playlist.
+ */
+static VALUE rbpod_track_collection_remove(VALUE self, VALUE track)
+{
+    VALUE playlist = rbpod_track_collection_playlist(self);
+    Itdb_Playlist *_playlist = TYPED_DATA_PTR(playlist, Itdb_Playlist);
+    Itdb_Track *_track = TYPED_DATA_PTR(track, Itdb_Track);
+
+    if (rb_obj_is_instance_of(track, cRbPodTrack) == FALSE) {
+        rb_raise(eRbPodError, "Invalid Arguments: Expected RbPod::Track, got %s", StringValueCStr(playlist));
+        return Qnil;
+    }
+
+    itdb_playlist_remove_track(_playlist, _track);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *     insert(track, position = -1) -> nil
+ *
+ * Adds a given RbPod::Track +track+ to the playlist at +position+. If +position+
+ * was not supplied, +track+ will be appended to the end of the playlist.
+ */
+static VALUE rbpod_track_collection_insert(int argc, VALUE *argv, VALUE self)
+{
+    VALUE playlist = rbpod_track_collection_playlist(self);
+    Itdb_Playlist *_playlist = TYPED_DATA_PTR(playlist, Itdb_Playlist);
+    VALUE track = Qnil, position = Qnil;
+    Itdb_Track *_track = NULL;
+    gint32 _position = 0;
+
+    if (rb_scan_args(argc, argv, "11", &track, &position) < 1) {
+        rb_raise(eRbPodError, "Invalid arguments: Expected >= 1 argument!");
+        return Qnil;
+    }
+
+    _track    = TYPED_DATA_PTR(track, Itdb_Track);
+    _position = NIL_P(position) ? -1 : NUM2INT(position);
+
+    /* We we given a track? */
+    if (rb_obj_is_instance_of(track, cRbPodTrack) == FALSE) {
+        rb_raise(eRbPodError, "Invalid argument: expected RbPod::Track, got %s", StringValueCStr(playlist));
+        return Qnil;
+    }
+
+    itdb_playlist_add_track(_playlist, _track, _position);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *     size() -> integer
+ *
+ * Returns the total number of tracks in this playlist.
+ */
+static VALUE rbpod_track_collection_size(VALUE self)
+{
+    VALUE playlist = rbpod_track_collection_playlist(self);
+    Itdb_Playlist *_playlist = TYPED_DATA_PTR(playlist, Itdb_Playlist);
+    return INT2NUM(itdb_playlist_tracks_number(_playlist));
 }
 
 /*
@@ -62,6 +154,17 @@ void Init_rbpod_track_collection(void)
 
     rb_define_method(cRbPodTrackCollection, "playlist", rbpod_track_collection_playlist, 0);
 
+    rb_define_method(cRbPodTrackCollection, "size", rbpod_track_collection_size, 0);
+
+    rb_define_method(cRbPodTrackCollection, "insert", rbpod_track_collection_insert, -1);
+
+    rb_define_method(cRbPodTrackCollection, "remove", rbpod_track_collection_remove, 1);
+
+    rb_define_method(cRbPodTrackCollection, "include?", rbpod_track_collection_include, 1);
+
+    /* Syntactic sugar for adding a track. */
+    rb_define_alias(cRbPodTrackCollection, "<<", "insert");
+
     return;
 }
 

data/ext/rbpod/utilities.c

@@ -0,0 +1,27 @@
+/* utilities.c */
+
+#include "rbpod.h"
+
+/*
+ * This is a hack used to inject a pointer from the data of one class instance into another.
+ */
+inline VALUE rb_class_new_instance_with_data(int argc, VALUE *argv, VALUE class, void *handle)
+{
+    /* Create a new instance of this class. */
+    VALUE instance = rb_class_new_instance(argc, argv, class);
+    /* Assign it's DATA pointer to the given handle. */
+    DATA_PTR(instance) = handle;
+    /* Return the instance. */
+    return instance;
+}
+
+/*
+ * This is a hack so that including a module will trigger the +included+ singleton method.
+ */
+inline void rb_real_include_module(VALUE klass, VALUE module)
+{
+    ID included = rb_intern("included");
+    rb_include_module(klass, module);
+    rb_funcall(mRbPodCollection, included, 1, klass);
+}
+

data/lib/rbpod/version.rb

@@ -1,3 +1,3 @@
 module RbPod # :nodoc:
-  VERSION = "0.0.5" # :nodoc:
+  VERSION = "0.0.6" # :nodoc:
 end

data/spec/rbpod/playlist_collection_spec.rb

@@ -41,4 +41,24 @@ describe RbPod::PlaylistCollection do
       collection.include?(anonymous_playlist).should be_false
     end
   end
+
+  let (:playlist) { RbPod::Playlist.new() }
+
+  describe '#insert' do
+    it 'should add a playlist to the database' do
+      collection.insert(playlist)
+      collection.database.save!
+      collection.include?(playlist).should be_true
+    end
+  end
+
+  describe '#remove' do
+    it 'should remove a playlist from the database' do
+      collection.insert(playlist)
+      collection.database.save!
+      collection.remove(playlist)
+      collection.database.save!
+      collection.include?(playlist).should be_false
+    end
+  end
 end

data/spec/rbpod/playlist_spec.rb

@@ -1,3 +1,60 @@
 describe RbPod::Playlist do
-  # Nothing yet.
+  context 'with a new playlist' do
+    let (:playlist) { RbPod::Playlist.new }
+
+    describe '#initialize' do
+      it 'should return a new playlist' do
+        playlist.should be_instance_of(RbPod::Playlist)
+      end
+    end
+
+    describe '#name' do
+      it 'should be "New Playlist"' do
+        playlist.name.should be_kind_of(String)
+        playlist.name.should eq('New Playlist')
+      end
+    end
+
+    describe '#created_on' do
+      it 'should have a creation date' do
+        playlist.created_on.should be_kind_of(Time)
+      end
+    end
+
+    describe '#length' do
+      it 'should contain zero tracks' do
+        playlist.length.should be_kind_of(Integer)
+        playlist.length.should eq(0)
+      end
+    end
+
+    describe '#tracks' do
+      it 'should return a collection of tracks' do
+        playlist.tracks.should be_instance_of(RbPod::TrackCollection)
+      end
+
+      it 'should have zero tracks within it' do
+        playlist.tracks.size.should be_kind_of(Integer)
+        playlist.tracks.size.should eq(0)
+      end
+    end
+
+    describe '#smart?' do
+      it 'should not be a smart playlist' do
+        playlist.should_not be_smart
+      end
+    end
+
+    describe '#master?' do
+      it 'should not be the master playlist' do
+        playlist.should_not be_master
+      end
+    end
+
+    describe '#podcast?' do
+      it 'should not be the podcast playlist' do
+        playlist.should_not be_podcast
+      end
+    end
+  end
 end