mockspotify 0.0.1 → 0.1.0

data/lib/mockspotify.rb

@@ -1,11 +1,41 @@
+require 'ffi'
 require 'rbconfig'
 
-module MockSpotify
-  VERSION = "0.0.1"
+module Spotify
+  module Mock
+    VERSION = '0.1.0'
 
-  class << self
-    def lib_path
+    # @return [String] path to the libmockspotify C extension binary.
+    def self.path
       File.expand_path('../../src/libmockspotify.', __FILE__) << RbConfig::CONFIG['DLEXT']
     end
+
+    # Overridden to always ffi_lib the mock path.
+    def ffi_lib(*)
+      super(Mock.path)
+    end
+
+    # Overriden to not throw an error on missing functions.
+    def attach_function(*)
+      super
+    rescue FFI::NotFoundError => e
+      warn "#{e.message}" if $VERBOSE
+    end
   end
+
+  extend FFI::Library
+  extend Mock
+  require 'spotify'
+
+  $VERBOSE = true
+  attach_function :mock_user, :mocksp_user_create, [:string, :string, :string, :string, :relation_type, :bool], :user
+  attach_function :mock_track, :mocksp_track_create, [:string, :int, :array, :pointer, :int, :int, :int, :int, :error, :bool], :track
+  attach_function :mock_image, :mocksp_image_create, [:image_id, :imageformat, :size_t, :pointer, :error], :image
+  attach_function :mock_artist, :mocksp_artist_create, [:string, :bool], :artist
+  attach_function :mock_album, :mocksp_album_create, [:string, :artist, :int, :pointer, :image_id, :albumtype, :bool, :bool], :album
+
+  attach_function :mock_artistbrowse, :mocksp_artistbrowse_create, [:artist, :bool], :artistbrowse
+
+  attach_function :mock_playlist_event, :mocksp_playlist_event, [:int, :playlist], :void
+  $VERBOSE = false
 end

data/mockspotify.gemspec

@@ -13,6 +13,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib", "src"]
   gem.extensions    << 'src/extconf.rb'
 
-  gem.version     = MockSpotify::VERSION
+  gem.add_dependency 'spotify'
+
+  gem.version     = Spotify::Mock::VERSION
   gem.platform    = Gem::Platform::RUBY
 end

data/src/album.c

@@ -5,13 +5,11 @@
 /*** MockSpotify API ***/
 
 sp_album *
-mocksp_album_create(char *name, sp_artist *artist, int year, byte * cover,
-                    int type, int loaded, int available)
+mocksp_album_create(const char *name, sp_artist *artist, int year, const byte *cover,
+                    sp_albumtype type, bool loaded, bool available)
 {
-    sp_album *a;
+    sp_album *a = ALLOC(sp_album);
 
-    a = malloc(sizeof(sp_album));
-    memset(a, 0, sizeof(sp_album));
     strcpy(a->name, name);
     a->artist = artist;
     a->year = year;

data/src/artist.c

@@ -7,10 +7,7 @@
 sp_artist *
 mocksp_artist_create(const char *name, int loaded)
 {
-    sp_artist *a;
-
-    a = malloc(sizeof(sp_artist));
-    memset(a, 0, sizeof(sp_artist));
+    sp_artist *a = ALLOC(sp_artist);
     strcpy(a->name, name);
     a->loaded = loaded;
     return a;

data/src/libmockspotify.h

@@ -28,7 +28,7 @@ struct sp_album {
     int year;
     byte cover[20];
     int type;
-    int loaded;
+    bool loaded;
     bool available;
 };
 
@@ -141,8 +141,8 @@ mocksp_playlist_event(event_type event, sp_playlist *p);
 /*** Mock object creation ***/
 
 sp_album *
-mocksp_album_create(char *name, sp_artist *artist, int year, byte *cover,
-                    int type, int loaded, int available);
+mocksp_album_create(const char *name, sp_artist *artist, int year, const byte *cover,
+                    sp_albumtype type, bool loaded, bool available);
 
 sp_albumbrowse *
 mocksp_albumbrowse_create(sp_album *album, bool loaded);
@@ -154,15 +154,15 @@ sp_artistbrowse *
 mocksp_artistbrowse_create(sp_artist *artist, bool loaded);
 
 sp_playlist *
-mocksp_playlist_create(char *name);
+mocksp_playlist_create(const char *name);
 
 sp_track *
-mocksp_track_create(char *name, int num_artists, sp_artist ** artists,
+mocksp_track_create(const char *name, int num_artists, sp_artist ** artists,
                     sp_album * album, int duration, int popularity,
-                    int disc, int index, sp_error error, int loaded);
+                    int disc, int index, sp_error error, bool loaded);
 
 sp_user *
-mocksp_user_create(char *canonical_name, char *display_name, char *full_name,
-                   char *picture, sp_relation_type relation, bool loaded);
+mocksp_user_create(const char *canonical_name, const char *display_name, const char *full_name,
+                   const char *picture, sp_relation_type relation, bool loaded);
 
 #endif /* LIBMOCKSPOTIFY_API_H */

data/src/link.c

@@ -30,7 +30,7 @@ sp_link *
 sp_link_create_from_user(sp_user *user)
 {
   char *link = ALLOC_N(char, 1024);
-  snprintf(link, "spotify:user:%s", user->canonical_name);
+  sprintf(link, "spotify:user:%s", user->canonical_name);
   return sp_link_create_from_string(link);
 }
 

data/src/search.c

@@ -20,7 +20,7 @@ sp_search_create(sp_session *session, const char *query, int track_offset,
                  int artist_offset, int artist_count,
                  search_complete_cb *callback, void *userdata)
 {
-    sp_search *search = malloc(sizeof(sp_search));
+    sp_search *search = ALLOC(sp_search);
 
     if (!strncmp(query, "!loaded", 7))
         search->loaded = 0;
@@ -30,10 +30,11 @@ sp_search_create(sp_session *session, const char *query, int track_offset,
     search->num_albums = 3;
     search->num_artists = 2;
     search->total_tracks = 24;
-    search->query = malloc(strlen(query) + 1);
+    search->query = ALLOC_N(char, strlen(query) + 1);
     strcpy(search->query, query);
     search->error = 3;
-    search->did_you_mean = "did_you_mean";
+    search->did_you_mean = ALLOC_N(char, strlen("did_you_mean") + 1);
+    sprintf(search->did_you_mean, "did_you_mean");
     search->artist[0] = mocksp_artist_create("foo", 1);
     search->artist[1] = mocksp_artist_create("bar", 1);
     search->album[0] = mocksp_album_create("baz", search->artist[0], 2001,

data/src/track.c

@@ -5,14 +5,12 @@
 /*** MockSpotify API ***/
 
 sp_track *
-mocksp_track_create(char *name, int num_artists, sp_artist **artists,
+mocksp_track_create(const char *name, int num_artists, sp_artist **artists,
                     sp_album *album, int duration, int popularity,
-                    int disc, int index, sp_error error, int loaded)
+                    int disc, int index, sp_error error, bool loaded)
 {
-    sp_track *t;
+    sp_track *t = ALLOC(sp_track);
 
-    t = malloc(sizeof(sp_track));
-    memset(t, 0, sizeof(sp_track));
     strcpy(t->name, name);
     t->loaded = loaded;
     t->disc = disc;
@@ -22,6 +20,7 @@ mocksp_track_create(char *name, int num_artists, sp_artist **artists,
     t->popularity = popularity;
     t->album = album;
     t->starred = 0;
+
     return t;
 }
 

data/src/user.c

@@ -5,15 +5,15 @@
 /*** MockSpotify API ***/
 
 sp_user *
-mocksp_user_create(char *canonical_name, char *display_name, char *full_name,
-                   char *picture, sp_relation_type relation, bool loaded)
+mocksp_user_create(const char *canonical_name, const char *display_name, const char *full_name,
+                   const char *picture, sp_relation_type relation, bool loaded)
 {
     sp_user *user = ALLOC(sp_user);
 
-    user->canonical_name = canonical_name;
-    user->display_name = display_name;
-    user->full_name = full_name;
-    user->picture = picture;
+    strcpy(user->canonical_name, canonical_name);
+    strcpy(user->display_name, display_name);
+    strcpy(user->full_name, full_name);
+    strcpy(user->picture, picture);
     user->relation = relation;
     user->loaded = loaded;
 

data/test/mockspotify_spec.rb

@@ -1,12 +1,31 @@
 require 'mockspotify'
 require 'minitest/autorun'
 
-describe MockSpotify do
+describe Spotify::Mock do
   it "should define VERSION" do
-    MockSpotify::VERSION.must_be_kind_of String
+    Spotify::Mock::VERSION.must_be_kind_of String
   end
 
   it "should provide a path to libmockspotify" do
-    File.exist?(MockSpotify.lib_path).must_equal true
+    Spotify::Mock.path.must_be_kind_of String
+    Spotify::Mock.path.must_match /libmockspotify\.(so|bundle)/
+  end
+
+  it "should have injected itself into Spotify's ancestor chain" do
+    Spotify.singleton_class.ancestors.take(2).must_equal [Spotify::Mock, FFI::Library]
+  end
+
+  describe ".mock_artist" do
+    before do
+      @artist = Spotify.mock_artist "Bonkers", true
+    end
+
+    it "should have the proper name" do
+      Spotify.artist_name(@artist).must_equal "Bonkers"
+    end
+
+    it "should have the proper load status" do
+      Spotify.artist_is_loaded(@artist).must_equal true
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mockspotify
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2011-07-20 00:00:00.000000000Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spotify
+  requirement: &2157317180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157317180
 description: 
 email: kim@burgestrand.se
 executables: []