rbpod 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rbpod.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joshua M. Keyes
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# RbPod
+
+A Ruby interface to the libgpod library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rbpod'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rbpod
+
+## Usage
+
+Functional for most read-only purposes.
+
+    #!/usr/bin/env ruby
+
+    require 'rbpod'
+
+    # Explicitly load a database from the filesystem -- can be a mount point to an iPod.
+    database = RbPod::Database.new('/mnt/ipod/') # => #<RbPod::Database:0x8733fa4>
+
+    database.version       # => 42
+    database.mountpoint    # => "/mnt/ipod/"
+    database.filename      # => "/mnt/ipod/iPod_Control/iTunes/iTunesDB"
+    database.synchronized? # => true
+
+    # Device information, including model name, number, and capacity.
+    database.device.capacity     # => 4.0
+    database.device.generation   # => "Nano Video (3rd Gen.)"
+    database.device.model_name   # => "Nano (Silver)"
+    database.device.model_number # => "A978"
+
+    # Device feature support detection.
+    database.device.supports_photos?         # => true
+    database.device.supports_videos?         # => true
+    database.device.supports_artwork?        # => true
+    database.device.supports_podcasts?       # => true
+    database.device.supports_chapter_images? # => true
+
+    # Device SysInfo read/write.
+    database.device['ModelNumStr'] # => "xA978"
+    database.device['PotsdamConf45'] = "Kilroy Was Here"
+    database.device.save!
+
+    # Playlists (includes enumerable)
+    database.playlists.map(&:name) # => ["iPod", "Podcasts", "Recently Added"]
+
+    # Track Listing (also enumerable)
+    database.tracks.count        # => 400
+    database.tracks.first.artist # => "Steppenwolf"
+    database.tracks.first.title  # => "Born To Be Wild"
+
+It's alpha quality -- many pieces still need to be implemented. Patches welcome.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rbpod

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'rbpod'

data/ext/rbpod/collection.c

@@ -0,0 +1,104 @@
+/* collection.c */
+
+#include "rbpod.h"
+#include "collection.h"
+
+VALUE cRbPodCollection;
+
+struct collection { VALUE klass; GList *list; };
+
+static inline struct collection *rbpod_collection_unwrap(VALUE self) {
+    struct collection *collection = NULL;
+    Data_Get_Struct(self, struct collection, collection);
+    return collection;
+}
+
+static VALUE rbpod_collection_get(VALUE self, VALUE key) {
+    struct collection *collection = rbpod_collection_unwrap(self);
+    GList *current = NULL;
+
+    if (FIXNUM_P(key) == FALSE)
+        return Qnil;
+
+    current = g_list_nth(collection->list, FIX2INT(key));
+
+    return Data_Wrap_Struct(collection->klass, NULL, NULL, (void *) current->data);;
+}
+
+static VALUE rbpod_collection_last(VALUE self) {
+    struct collection *collection = rbpod_collection_unwrap(self);
+    GList *current = g_list_last(collection->list);
+    return Data_Wrap_Struct(collection->klass, NULL, NULL, (void *) current->data);
+}
+
+static VALUE rbpod_collection_first(VALUE self) {
+    struct collection *collection = rbpod_collection_unwrap(self);
+    GList *current = g_list_first(collection->list);
+    return Data_Wrap_Struct(collection->klass, NULL, NULL, (void *) current->data);
+}
+
+static VALUE rbpod_collection_count(VALUE self) {
+    struct collection *collection = rbpod_collection_unwrap(self);
+    return INT2NUM(g_list_length(collection->list));
+}
+
+static VALUE rbpod_collection_each(VALUE self) {
+    struct collection *collection = rbpod_collection_unwrap(self);
+    GList *current = NULL;
+    VALUE item;
+
+    if (rb_block_given_p() == TRUE) {
+        /* If we were supplied a block, enumerate the entire list. */
+        for (current = collection->list; current != NULL; current = current->next) {
+            item = Data_Wrap_Struct(collection->klass, NULL, NULL, (void *) current->data);
+            rb_yield(item);
+        }
+        return Qnil;
+    } else {
+        /* Otherwise return an enumerator from this method to the caller. */
+        return rb_funcall(self, rb_intern("enum_for"), 1, ID2SYM(rb_intern("each")));
+    }
+}
+
+static VALUE rbpod_collection_initialize(VALUE self) {
+    return self;
+}
+
+static void rbpod_collection_deallocate(void *handle) {
+    struct collection *collection = (struct collection *) handle;
+
+    if (collection->list != NULL)
+        g_list_free(collection->list);
+
+    xfree(handle);
+    return;
+}
+
+inline VALUE rbpod_collection_wrap(GList *list, VALUE type, gboolean freeable) {
+    struct collection *collection = ALLOC(struct collection);
+    collection->list  = list;
+    collection->klass = type;
+    return Data_Wrap_Struct(cRbPodCollection, NULL, freeable ? rbpod_collection_deallocate : NULL, (void *) collection);
+}
+
+static VALUE rbpod_collection_allocate(VALUE self) {
+    return rbpod_collection_wrap(g_list_alloc(), Qnil, TRUE);
+}
+
+void Init_rbpod_collection(void) {
+    cRbPodCollection = rb_define_class_under(mRbPod, "Collection", rb_cObject);
+
+    rb_define_alloc_func(cRbPodCollection, rbpod_collection_allocate);
+
+    rb_include_module(cRbPodCollection, rb_mEnumerable);
+
+    rb_define_method(cRbPodCollection, "initialize", rbpod_collection_initialize, 0);
+
+    rb_define_method(cRbPodCollection, "each", rbpod_collection_each, 0);
+    rb_define_method(cRbPodCollection, "count", rbpod_collection_count, 0);
+
+    rb_define_method(cRbPodCollection, "first", rbpod_collection_first, 0);
+    rb_define_method(cRbPodCollection, "last", rbpod_collection_last, 0);
+
+    rb_define_method(cRbPodCollection, "[]", rbpod_collection_get, 1);
+}

data/ext/rbpod/collection.h

@@ -0,0 +1,12 @@
+/* collection.h */
+
+#ifndef RBPOD_COLLECTION_H
+#define RBPOD_COLLECTION_H
+
+extern VALUE cRbPodCollection;
+
+void Init_rbpod_collection(void);
+
+inline VALUE rbpod_collection_wrap(GList *list, VALUE type, gboolean freeable);
+
+#endif /* RBPOD_COLLECTION_H */

data/ext/rbpod/database.c

@@ -0,0 +1,173 @@
+/* database.c */
+
+#include "rbpod.h"
+#include "track.h"
+#include "device.h"
+#include "playlist.h"
+#include "database.h"
+#include "collection.h"
+
+/*
+ * Although libgpod has an itdb_new(), itdb_parse() also returns a pointer to a
+ * newly allocated Itdb_iTunesDB structure. Since overwriting the data pointer from
+ * Data_Get_Struct() at runtime is dangerous, we use a double-pointer to wrap the
+ * Itdb_iTunesDB handle, so as not to confuse the Ruby implementation internals.
+ */
+
+VALUE cRbPodDatabase;
+
+static inline Itdb_iTunesDB *rbpod_database_unwrap(VALUE self) {
+    Itdb_iTunesDB **database = NULL;
+    Data_Get_Struct(self, Itdb_iTunesDB *, database);
+    return *database;
+}
+
+static VALUE rbpod_database_write(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    gboolean success = itdb_write(database, NULL); /* TODO: Improve error handling. */
+    return BooleanValue(success);
+}
+
+static VALUE rbpod_database_is_synchronized(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    guint32 nontransferred = itdb_tracks_number_nontransferred(database);
+    return BooleanValue(nontransferred == 0);
+}
+
+static VALUE rbpod_database_playlists_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return rbpod_collection_wrap(database->playlists, cRbPodPlaylist, FALSE);
+}
+
+static VALUE rbpod_database_tracks_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return rbpod_collection_wrap(database->tracks, cRbPodTrack, FALSE);
+}
+
+static VALUE rbpod_database_device_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return rbpod_device_wrap(database->device, FALSE);
+}
+
+static VALUE rbpod_database_filename_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return rb_str_new2(database->filename);
+}
+
+static VALUE rbpod_database_version_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return INT2NUM(database->version);
+}
+
+static VALUE rbpod_database_id_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return INT2NUM(database->id);
+}
+
+static VALUE rbpod_database_mountpoint_get(VALUE self) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    return rb_str_new2(itdb_get_mountpoint(database));
+}
+
+static VALUE rbpod_database_mountpoint_set(VALUE self, VALUE path) {
+    Itdb_iTunesDB *database = rbpod_database_unwrap(self);
+    itdb_set_mountpoint(database, StringValueCStr(path));
+    return rbpod_database_mountpoint_get(self);
+}
+
+static void rbpod_database_deallocate(void *handle) {
+    Itdb_iTunesDB **database = (Itdb_iTunesDB **) handle;
+    itdb_free(*database);
+    xfree(handle);
+    return;
+}
+
+static VALUE rbpod_database_create(VALUE self, VALUE device_name, VALUE mount_point, VALUE model_number) {
+    Itdb_iTunesDB **database = ALLOC(Itdb_iTunesDB *);
+    gchar *_mount_point, *_model_number, *_device_name;
+
+    _device_name  = StringValueCStr(device_name);
+    _mount_point  = StringValueCStr(mount_point);
+
+    /* GPod can function with a NULL model number, however, artwork will not function. */
+    _model_number = !NIL_P(model_number) ? StringValueCStr(model_number) : NULL;
+
+    /* Initialize the iPod at this mount point, with this device name and model number. */
+    /* TODO: Improve error handling. */
+    if (itdb_init_ipod(_mount_point, _model_number, _device_name, NULL) == FALSE) {
+        free(database);
+        rb_raise(rb_eRuntimeError, "Unable to format this iPod.");
+        return Qfalse;
+    }
+
+    /* Parse the newly created database. */
+    /* TODO: Improve error handling. */
+    *database = itdb_parse(_mount_point, NULL);
+
+    if (*database == NULL) {
+        free(database);
+        rb_raise(rb_eRuntimeError, "Not an iPod mount point.");
+        return Qnil;
+    }
+
+    /* Return an instance of this class using the newly created database. */
+    return Data_Wrap_Struct(self, NULL, rbpod_database_deallocate, (void *) database);
+}
+
+static VALUE rbpod_database_initialize(VALUE self, VALUE mount_point) {
+    Itdb_iTunesDB **database;
+
+    /* Extract the wrapper from the class itself. */
+    Data_Get_Struct(self, Itdb_iTunesDB *, database);
+
+    /* Try to parse the database from the given mount point. */
+    /* TODO: Improve error handling. */
+    *database = itdb_parse(StringValueCStr(mount_point), NULL);
+
+    /* The given mount point was not an iPod mount point. */
+    if (*database == NULL) {
+        rb_raise(rb_eRuntimeError, "Not an iPod mount point.");
+        return Qnil;
+    }
+
+    return self;
+}
+
+inline VALUE rbpod_database_wrap(Itdb_iTunesDB **database, gboolean freeable) {
+    return Data_Wrap_Struct(cRbPodDatabase, NULL, freeable ? rbpod_database_deallocate : NULL, (void *) database);
+}
+
+static VALUE rbpod_database_allocate(VALUE self) {
+    Itdb_iTunesDB **database = ALLOC(Itdb_iTunesDB *);
+
+    /* Initialize a new, empty database. */
+    *database = itdb_new();
+
+    return rbpod_database_wrap(database, TRUE);
+}
+
+void Init_rbpod_database(void) {
+    cRbPodDatabase = rb_define_class_under(mRbPod, "Database", rb_cObject);
+
+    rb_define_alloc_func(cRbPodDatabase, rbpod_database_allocate);
+
+    rb_define_method(cRbPodDatabase, "initialize", rbpod_database_initialize, 1);
+
+    rb_define_singleton_method(cRbPodDatabase, "create!", rbpod_database_create, 3);
+
+    rb_define_method(cRbPodDatabase, "mountpoint", rbpod_database_mountpoint_get, 0);
+    rb_define_method(cRbPodDatabase, "mountpoint=", rbpod_database_mountpoint_set, 1);
+
+    rb_define_method(cRbPodDatabase, "id", rbpod_database_id_get, 0);
+    rb_define_method(cRbPodDatabase, "version", rbpod_database_version_get, 0);
+    rb_define_method(cRbPodDatabase, "filename", rbpod_database_filename_get, 0);
+
+    rb_define_method(cRbPodDatabase, "device", rbpod_database_device_get, 0);
+    rb_define_method(cRbPodDatabase, "tracks", rbpod_database_tracks_get, 0);
+    rb_define_method(cRbPodDatabase, "playlists", rbpod_database_playlists_get, 0);
+
+    rb_define_method(cRbPodDatabase, "synchronized?", rbpod_database_is_synchronized, 0);
+
+    rb_define_method(cRbPodDatabase, "write!", rbpod_database_write, 0);
+}
+

data/ext/rbpod/database.h

@@ -0,0 +1,12 @@
+/* database.h */
+
+#ifndef RBPOD_DATABASE_H
+#define RBPOD_DATABASE_H
+
+extern VALUE cRbPodDatabase;
+
+void Init_rbpod_database(void);
+
+inline VALUE rbpod_database_wrap(Itdb_iTunesDB **database, gboolean freeable);
+
+#endif /* RBPOD_DATABASE_H */

data/ext/rbpod/device.c

@@ -0,0 +1,136 @@
+/* device.c */
+
+#include "rbpod.h"
+#include "device.h"
+
+VALUE cRbPodDevice;
+
+static inline Itdb_Device *rbpod_device_unwrap(VALUE self) {
+    Itdb_Device *device = NULL;
+    Data_Get_Struct(self, Itdb_Device, device);
+    return device;
+}
+
+static VALUE rbpod_device_has_chapter_image_support(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    return BooleanValue(itdb_device_supports_chapter_image(device));
+}
+
+static VALUE rbpod_device_has_podcast_support(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    return BooleanValue(itdb_device_supports_podcast(device));
+}
+
+static VALUE rbpod_device_has_artwork_support(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    return BooleanValue(itdb_device_supports_artwork(device));
+}
+
+static VALUE rbpod_device_has_video_support(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    return BooleanValue(itdb_device_supports_video(device));
+}
+
+static VALUE rbpod_device_has_photo_support(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    return BooleanValue(itdb_device_supports_photo(device));
+}
+
+static VALUE rbpod_device_model_name_get(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    Itdb_IpodInfo *info = itdb_device_get_ipod_info(device);
+    return rb_str_new2(itdb_info_get_ipod_model_name_string(info->ipod_model));
+}
+
+static VALUE rbpod_device_model_number_get(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    Itdb_IpodInfo *info = itdb_device_get_ipod_info(device);
+    return rb_str_new2(info->model_number);
+}
+
+static VALUE rbpod_device_generation_get(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    const Itdb_IpodInfo *info = itdb_device_get_ipod_info(device);
+    return rb_str_new2(itdb_info_get_ipod_generation_string(info->ipod_generation));
+}
+
+static VALUE rbpod_device_capacity_get(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    const Itdb_IpodInfo *info = itdb_device_get_ipod_info(device);
+    return DBL2NUM(info->capacity);
+}
+
+static VALUE rbpod_device_sysinfo_get(VALUE self, VALUE key) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    gchar *value = NULL;
+    VALUE result;
+
+    value = itdb_device_get_sysinfo(device, StringValueCStr(key));
+    result = (value == NULL) ? Qnil : rb_str_new2(value);
+
+    g_free(value);
+    return result;
+
+}
+
+static VALUE rbpod_device_sysinfo_set(VALUE self, VALUE key, VALUE value) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    gchar *_value, *_key;
+
+    _key   = StringValueCStr(key);
+    _value = !NIL_P(value) ? StringValueCStr(value) : NULL;
+
+    itdb_device_set_sysinfo(device, _key, _value);
+
+    return rbpod_device_sysinfo_get(self, _key);
+}
+
+static VALUE rbpod_device_sysinfo_write(VALUE self) {
+    Itdb_Device *device = rbpod_device_unwrap(self);
+    /* TODO: Improve error handling. */
+    return BooleanValue(itdb_device_write_sysinfo(device, NULL));
+}
+
+static VALUE rbpod_device_initialize(VALUE self) {
+    /* Private. */
+    return self;
+}
+
+static void rbpod_device_deallocate(void *handle) {
+    itdb_device_free((Itdb_Device *) handle);
+}
+
+inline VALUE rbpod_device_wrap(Itdb_Device *device, gboolean freeable) {
+    return Data_Wrap_Struct(cRbPodDevice, NULL, freeable ? rbpod_device_deallocate : NULL, (void *) device);
+}
+
+static VALUE rbpod_device_allocate(VALUE self) {
+    return rbpod_device_wrap(itdb_device_new(), TRUE);
+}
+
+void Init_rbpod_device(void) {
+    cRbPodDevice = rb_define_class_under(mRbPod, "Device", rb_cObject);
+
+    rb_define_alloc_func(cRbPodDevice, rbpod_device_allocate);
+
+    /* We don't want to explicitly create these, so mark the constructor as private. */
+    rb_define_private_method(cRbPodDevice, "initialize", rbpod_device_initialize, 0);
+
+    rb_define_method(cRbPodDevice, "[]", rbpod_device_sysinfo_get, 1);
+    rb_define_method(cRbPodDevice, "[]=", rbpod_device_sysinfo_set, 2);
+    rb_define_method(cRbPodDevice, "save!", rbpod_device_sysinfo_write, 0);
+
+    rb_define_method(cRbPodDevice, "capacity", rbpod_device_capacity_get, 0);
+    rb_define_method(cRbPodDevice, "generation", rbpod_device_generation_get, 0);
+    rb_define_method(cRbPodDevice, "model_name", rbpod_device_model_name_get, 0);
+    rb_define_method(cRbPodDevice, "model_number", rbpod_device_model_number_get, 0);
+
+    rb_define_method(cRbPodDevice, "supports_photos?", rbpod_device_has_photo_support, 0);
+    rb_define_method(cRbPodDevice, "supports_videos?", rbpod_device_has_video_support, 0);
+    rb_define_method(cRbPodDevice, "supports_artwork?", rbpod_device_has_artwork_support, 0);
+    rb_define_method(cRbPodDevice, "supports_podcasts?", rbpod_device_has_podcast_support, 0);
+    rb_define_method(cRbPodDevice, "supports_chapter_images?", rbpod_device_has_chapter_image_support, 0);
+
+    return;
+}
+

data/ext/rbpod/device.h

@@ -0,0 +1,12 @@
+/* device.h */
+
+#ifndef RBPOD_DEVICE_H
+#define RBPOD_DEVICE_H
+
+extern VALUE cRbPodDevice;
+
+void Init_rbpod_device(void);
+
+inline VALUE rbpod_device_wrap(Itdb_Device *device, gboolean freeable);
+
+#endif /* RBPOD_DEVICE_H */

data/ext/rbpod/extconf.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+abort "Please install libgpod-1.0" unless pkg_config('libgpod-1.0')
+
+create_makefile('rbpod/rbpod')

data/ext/rbpod/playlist.c

@@ -0,0 +1,85 @@
+/* playlist.c */
+
+#include "rbpod.h"
+#include "track.h"
+#include "playlist.h"
+
+VALUE cRbPodPlaylist;
+
+static inline Itdb_Playlist *rbpod_playlist_unwrap(VALUE self) {
+    Itdb_Playlist *playlist = NULL;
+    Data_Get_Struct(self, Itdb_Playlist, playlist);
+    return playlist;
+}
+
+static VALUE rbpod_playlist_is_podcast(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return BooleanValue(itdb_playlist_is_podcasts(playlist));
+}
+
+static VALUE rbpod_playlist_is_master(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return BooleanValue(itdb_playlist_is_mpl(playlist));
+}
+
+static VALUE rbpod_playlist_is_smart(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return BooleanValue(playlist->is_spl);
+}
+
+static VALUE rbpod_playlist_tracks_get(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return rbpod_collection_wrap(playlist->members, cRbPodTrack, FALSE);
+}
+
+static VALUE rbpod_playlist_length_get(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return INT2NUM(playlist->num);
+}
+
+static VALUE rbpod_playlist_name_get(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return rb_str_new2(playlist->name);
+}
+
+static VALUE rbpod_playlist_id_get(VALUE self) {
+    Itdb_Playlist *playlist = rbpod_playlist_unwrap(self);
+    return INT2FIX(playlist->id);
+}
+
+static VALUE rbpod_playlist_initialize(VALUE self) {
+    return self;
+}
+
+static void rbpod_playlist_deallocate(void *handle) {
+    itdb_playlist_free((Itdb_Playlist *) handle);
+}
+
+inline VALUE rbpod_playlist_wrap(Itdb_Playlist *playlist, gboolean freeable) {
+    return Data_Wrap_Struct(cRbPodPlaylist, NULL, freeable ? rbpod_playlist_deallocate : NULL, (void *) playlist);
+}
+
+static VALUE rbpod_playlist_allocate(VALUE self) {
+    Itdb_Playlist *playlist = itdb_playlist_new("Untitled Playlist", FALSE);
+    return rbpod_playlist_wrap(playlist, TRUE);
+}
+
+void Init_rbpod_playlist(void) {
+    cRbPodPlaylist = rb_define_class_under(mRbPod, "Playlist", rb_cObject);
+
+    rb_define_alloc_func(cRbPodPlaylist, rbpod_playlist_allocate);
+
+    rb_define_method(cRbPodPlaylist, "initialize", rbpod_playlist_initialize, 0);
+
+    rb_define_method(cRbPodPlaylist, "id", rbpod_playlist_id_get, 0);
+    rb_define_method(cRbPodPlaylist, "name", rbpod_playlist_name_get, 0);
+    rb_define_method(cRbPodPlaylist, "length", rbpod_playlist_length_get, 0);
+    rb_define_method(cRbPodPlaylist, "tracks", rbpod_playlist_tracks_get, 0);
+
+    rb_define_method(cRbPodPlaylist, "smart_playlist?", rbpod_playlist_is_smart, 0);
+    rb_define_method(cRbPodPlaylist, "master_playlist?", rbpod_playlist_is_master, 0);
+    rb_define_method(cRbPodPlaylist, "podcast_playlist?", rbpod_playlist_is_podcast, 0);
+
+    return;
+}
+

data/ext/rbpod/playlist.h

@@ -0,0 +1,12 @@
+/* playlist.h */
+
+#ifndef RBPOD_PLAYLIST_H
+#define RBPOD_PLAYLIST_H
+
+extern VALUE cRbPodPlaylist;
+
+void Init_rbpod_playlist(void);
+
+inline VALUE rbpod_playlist_wrap(Itdb_Playlist *playlist, gboolean freeable);
+
+#endif /* RBPOD_PLAYLIST_H */

data/ext/rbpod/rbpod.c

@@ -0,0 +1,34 @@
+/* rbpod.c */
+
+#include "rbpod.h"
+#include "track.h"
+#include "device.h"
+#include "playlist.h"
+#include "database.h"
+#include "collection.h"
+
+VALUE mRbPod;
+
+void Init_rbpod(void) {
+    /* Set up the top-level RbPod module. */
+    mRbPod = rb_define_module("RbPod");
+
+    /* Set up the RbPod::Database class. */
+    Init_rbpod_database();
+
+    /* Set up the RbPod::Device class. */
+    Init_rbpod_device();
+
+    /* Set up the RbPod::Collection class. */
+    Init_rbpod_collection();
+
+    /* Set up the RbPod::Playlist class. */
+    Init_rbpod_playlist();
+
+    /* Set up the RbPod::Track class. */
+    Init_rbpod_track();
+
+    return;
+}
+
+

data/ext/rbpod/rbpod.h

@@ -0,0 +1,13 @@
+/* rbpod.h */
+
+#ifndef RBPOD_H
+#define RBPOD_H
+
+#include <ruby.h>
+#include <gpod/itdb.h>
+
+#define BooleanValue(value) (value) ? Qtrue : Qfalse
+
+extern VALUE mRbPod;
+
+#endif /* RBPOD_H */

data/ext/rbpod/track.c

@@ -0,0 +1,84 @@
+/* track.c */
+
+#include "rbpod.h"
+#include "track.h"
+
+VALUE cRbPodTrack;
+
+static inline Itdb_Track *rbpod_track_unwrap(VALUE self) {
+    Itdb_Track *track = NULL;
+    Data_Get_Struct(self, Itdb_Track, track);
+    return track;
+}
+
+static VALUE rbpod_track_is_transferred(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return BooleanValue(track->transferred);
+}
+
+static VALUE rbpod_track_ipod_path_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->ipod_path);
+}
+
+static VALUE rbpod_track_file_type_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->filetype);
+}
+
+static VALUE rbpod_track_artist_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->artist);
+}
+
+static VALUE rbpod_track_album_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->album);
+}
+
+static VALUE rbpod_track_title_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->title);
+}
+
+static VALUE rbpod_track_id_get(VALUE self) {
+    Itdb_Track *track = rbpod_track_unwrap(self);
+    return rb_str_new2(track->filetype);
+}
+
+static VALUE rbpod_track_initialize(VALUE self) {
+    return self;
+}
+
+static void rbpod_track_deallocate(void *handle) {
+    itdb_track_free((Itdb_Track *) handle);
+    return;
+}
+
+inline VALUE rbpod_track_wrap(Itdb_Track *track, gboolean freeable) {
+    return Data_Wrap_Struct(cRbPodTrack, NULL, freeable ? rbpod_track_deallocate : NULL, (void *) track);
+}
+
+static VALUE rbpod_track_allocate(VALUE self) {
+    return rbpod_track_wrap(itdb_track_new(), TRUE);
+}
+
+void Init_rbpod_track(void) {
+    cRbPodTrack = rb_define_class_under(mRbPod, "Track", rb_cObject);
+
+    rb_define_alloc_func(cRbPodTrack, rbpod_track_allocate);
+
+    rb_define_method(cRbPodTrack, "initialize", rbpod_track_initialize, 0);
+
+    rb_define_method(cRbPodTrack, "id", rbpod_track_id_get, 0);
+    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, "file_type", rbpod_track_file_type_get, 0);
+    rb_define_method(cRbPodTrack, "ipod_path", rbpod_track_ipod_path_get, 0);
+
+    rb_define_method(cRbPodTrack, "transferred?", rbpod_track_is_transferred, 0);
+
+    return;
+}
+

data/ext/rbpod/track.h

@@ -0,0 +1,12 @@
+/* track.h */
+
+#ifndef RBPOD_TRACK_H
+#define RBPOD_TRACK_H
+
+extern VALUE cRbPodTrack;
+
+void Init_rbpod_track(void);
+
+inline VALUE rbpod_track_wrap(Itdb_Track *track, gboolean freeable);
+
+#endif /* RBPOD_TRACK_H */

data/lib/rbpod/version.rb

@@ -0,0 +1,3 @@
+module RbPod
+  VERSION = "0.0.1"
+end

data/lib/rbpod.rb

@@ -0,0 +1,2 @@
+require 'rbpod/version'
+require 'rbpod/rbpod'

data/rbpod.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rbpod/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbpod"
+  spec.version       = RbPod::VERSION
+
+  spec.authors       = ["Joshua M. Keyes"]
+  spec.email         = ["joshua.michael.keyes@gmail.com"]
+
+  spec.summary       = %q{Ruby bindings to the libgpod library.}
+  spec.description   = %q{Lightweight native bindings to the libgpod library.}
+  spec.homepage      = "https://github.com/jmkeyes/rbpod"
+  spec.requirements << 'libgpod-1.0'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.extensions    = ["ext/rbpod/extconf.rb"]
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+
+  spec.add_dependency 'trollop', '~> 2.0'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rbpod
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joshua M. Keyes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Lightweight native bindings to the libgpod library.
+email:
+- joshua.michael.keyes@gmail.com
+executables:
+- rbpod
+extensions:
+- ext/rbpod/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rbpod
+- ext/rbpod/collection.c
+- ext/rbpod/collection.h
+- ext/rbpod/database.c
+- ext/rbpod/database.h
+- ext/rbpod/device.c
+- ext/rbpod/device.h
+- ext/rbpod/extconf.rb
+- ext/rbpod/playlist.c
+- ext/rbpod/playlist.h
+- ext/rbpod/rbpod.c
+- ext/rbpod/rbpod.h
+- ext/rbpod/track.c
+- ext/rbpod/track.h
+- lib/rbpod.rb
+- lib/rbpod/version.rb
+- rbpod.gemspec
+homepage: https://github.com/jmkeyes/rbpod
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- libgpod-1.0
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby bindings to the libgpod library.
+test_files: []