mockspotify 0.0.1

data/.gitignore

@@ -0,0 +1,27 @@
+Makefile
+Makefile.in
+aclocal.m4
+autom4te.cache/
+config.guess
+config.h
+config.h.in
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+m4/
+missing
+src/.deps/
+src/.libs/
+src/*.o
+src/*.la
+src/*.lo
+src/Makefile
+src/Makefile.in
+stamp-h1
+*.bundle
+pkg/

data/Gemfile

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

data/Makefile.am

@@ -0,0 +1,3 @@
+SUBDIRS = src
+
+ACLOCAL_AMFLAGS = -I m4

data/README.rst

@@ -0,0 +1,55 @@
+libmockspotify
+==============
+
+A mock of libspotify for use in development of language bindings.
+
+This project was started in July 2011 with the goal of splitting out
+pyspotify's mock of libspotify, so that it could be reused by the developers of
+the Node.js and Ruby bindings for libspotify.
+
+Coordination of the development efforts happens on GitHub and #spotify on
+Freenode.
+
+Note about my fork
+------------------
+To ease usage in my own development, I’ve turned this project into a
+Ruby gem. This allows you to install it as a gem, and also allows you
+to retrieve the path to the compiled binary.
+
+Installing it as a gem:
+
+::
+
+    gem install mockspotify
+
+Using its’ API (one method):
+
+::
+
+    require 'mockspotify'
+    MockSpotify.lib_path # => path/to/gem/src/libmockspotify.extension
+
+You can then use this to bind this library using Ruby FFI:
+
+::
+
+    require 'ffi'
+    require 'mockspotify'
+
+    module Spotify
+      extend FFI::Library
+      ffi_lib MockSpotify.lib_path
+
+      attach_function …, etc
+    end
+
+Manual compilation
+------------------
+If you ever want to do it, here you go:
+
+::
+
+    $ ./autogen.sh
+    $ ./configure
+    $ make
+    # make install

data/Rakefile

@@ -0,0 +1,16 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+task :compile do
+  Dir.chdir('src') do
+    sh 'ruby extconf.rb'
+    sh 'make'
+  end
+end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.pattern = 'test/*_spec.rb'
+end
+
+task :test => :compile

data/autogen.sh

@@ -0,0 +1,4 @@
+#! /bin/sh
+
+libtoolize \
+&& autoreconf --install

data/configure.ac

@@ -0,0 +1,10 @@
+AC_INIT([libmockspotify], [0.1], [http://github.com/mopidy/libmockspotify])
+AM_INIT_AUTOMAKE([foreign -Wall -Werror])
+
+AC_PROG_CC
+AC_PROG_LIBTOOL
+
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_FILES([Makefile src/Makefile])
+AC_OUTPUT

data/lib/mockspotify.rb

@@ -0,0 +1,11 @@
+require 'rbconfig'
+
+module MockSpotify
+  VERSION = "0.0.1"
+
+  class << self
+    def lib_path
+      File.expand_path('../../src/libmockspotify.', __FILE__) << RbConfig::CONFIG['DLEXT']
+    end
+  end
+end

data/mockspotify.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mockspotify', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name     = "mockspotify"
+  gem.summary  = %Q{A mock of libspotify for use in development of language bindings}
+  gem.homepage = "https://github.com/Burgestrand/libmockspotify"
+  gem.authors  = ["Kim Burgestrand"]
+  gem.email    = 'kim@burgestrand.se'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.executables   = []
+  gem.require_paths = ["lib", "src"]
+  gem.extensions    << 'src/extconf.rb'
+
+  gem.version     = MockSpotify::VERSION
+  gem.platform    = Gem::Platform::RUBY
+end

data/src/Makefile.am

@@ -0,0 +1,18 @@
+lib_LTLIBRARIES = libmockspotify.la
+include_HEADERS = libmockspotify.h
+
+AM_CFLAGS = -Wall
+
+libmockspotify_la_SOURCES = album.c 		\
+			    albumbrowse.c	\
+			    artist.c		\
+			    artistbrowse.c	\
+			    error.c		\
+			    image.c		\
+			    link.c		\
+			    playlist.c		\
+			    search.c		\
+			    session.c		\
+			    track.c		\
+			    user.c		\
+			    util.c

data/src/album.c

@@ -0,0 +1,77 @@
+#include <stdlib.h>
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+
+sp_album *
+mocksp_album_create(char *name, sp_artist *artist, int year, byte * cover,
+                    int type, int loaded, int available)
+{
+    sp_album *a;
+
+    a = malloc(sizeof(sp_album));
+    memset(a, 0, sizeof(sp_album));
+    strcpy(a->name, name);
+    a->artist = artist;
+    a->year = year;
+    memcpy(a->cover, cover, 20);
+    a->type = type;
+    a->loaded = loaded;
+    a->available = available;
+    return a;
+}
+
+/*** Spotify API ***/
+
+void
+sp_album_add_ref(sp_album *a)
+{
+}
+
+void
+sp_album_release(sp_album *a)
+{
+}
+
+bool
+sp_album_is_loaded(sp_album *a)
+{
+    return a->loaded;
+}
+
+bool
+sp_album_is_available(sp_album *a)
+{
+    return a->available;
+}
+
+sp_artist *
+sp_album_artist(sp_album *a)
+{
+    return a->artist;
+}
+
+const byte *
+sp_album_cover(sp_album *a)
+{
+    return a->cover;
+}
+
+const char *
+sp_album_name(sp_album *a)
+{
+    return a->name;
+}
+
+int
+sp_album_year(sp_album *a)
+{
+    return a->year;
+}
+
+sp_albumtype
+sp_album_type(sp_album *a)
+{
+    return a->type;
+}

data/src/albumbrowse.c

@@ -0,0 +1,77 @@
+#include <stdlib.h>
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+
+sp_albumbrowse *
+mocksp_albumbrowse_create(sp_album *album, bool loaded)
+{
+    sp_albumbrowse *ab;
+
+    ab = malloc(sizeof(sp_albumbrowse));
+    ab->loaded = loaded;
+    ab->album = album;
+    return ab;
+}
+
+/*** Spotify API ***/
+
+void
+sp_albumbrowse_add_ref(sp_albumbrowse *ab)
+{
+}
+
+void
+sp_albumbrowse_release(sp_albumbrowse *ab)
+{
+}
+
+sp_track *
+sp_albumbrowse_track(sp_albumbrowse *ab, int index)
+{
+    sp_track *track;
+
+    switch (index) {
+    case 0:
+        track = mocksp_track_create("foo", 1, &(ab->album->artist), ab->album,
+                                    123, 0, 1, 1, SP_ERROR_OK, 1);
+        break;
+    case 1:
+        track = mocksp_track_create("bar", 1, &(ab->album->artist), ab->album,
+                                    123, 0, 1, 2, SP_ERROR_OK, 1);
+        break;
+    case 2:
+        track = mocksp_track_create("baz", 1, &(ab->album->artist), ab->album,
+                                    123, 0, 1, 3, SP_ERROR_OK, 1);
+        break;
+    default:
+        track = NULL;
+        break;
+    }
+    return track;
+}
+
+int
+sp_albumbrowse_num_tracks(sp_albumbrowse *ab)
+{
+    return 3;
+}
+
+bool
+sp_albumbrowse_is_loaded(sp_albumbrowse *ab)
+{
+    return ab->loaded;
+}
+
+sp_albumbrowse *
+sp_albumbrowse_create(sp_session *s, sp_album *a,
+                      albumbrowse_complete_cb cb, void *userdata)
+{
+    sp_albumbrowse *ab;
+
+    ab = mocksp_albumbrowse_create(a, 1);
+    if (cb)
+        cb(ab, userdata);
+    return ab;
+}

data/src/artist.c

@@ -0,0 +1,41 @@
+#include <stdlib.h>
+#include <string.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+
+sp_artist *
+mocksp_artist_create(const char *name, int loaded)
+{
+    sp_artist *a;
+
+    a = malloc(sizeof(sp_artist));
+    memset(a, 0, sizeof(sp_artist));
+    strcpy(a->name, name);
+    a->loaded = loaded;
+    return a;
+}
+
+/*** Spotify API ***/
+
+void
+sp_artist_add_ref(sp_artist *a)
+{
+}
+
+const char *
+sp_artist_name(sp_artist *a)
+{
+    return a->name;
+}
+
+bool
+sp_artist_is_loaded(sp_artist *a)
+{
+    return a->loaded;
+}
+
+void
+sp_artist_release(sp_artist *a)
+{
+}

data/src/artistbrowse.c

@@ -0,0 +1,110 @@
+#include <stdlib.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+
+sp_artistbrowse *
+mocksp_artistbrowse_create(sp_artist * artist, bool loaded)
+{
+    sp_artistbrowse *ab;
+
+    ab = malloc(sizeof(sp_artistbrowse));
+    ab->loaded = loaded;
+    ab->artist = artist;
+    return ab;
+}
+
+/*** Spotify API ***/
+
+void
+sp_artistbrowse_add_ref(sp_artistbrowse * ab)
+{
+}
+
+void
+sp_artistbrowse_release(sp_artistbrowse * ab)
+{
+}
+
+sp_artistbrowse *
+sp_artistbrowse_create(sp_session * s, sp_artist * a,
+                       artistbrowse_complete_cb cb, void *userdata)
+{
+    sp_artistbrowse *ab;
+
+    ab = mocksp_artistbrowse_create(a, 1);
+    if (cb)
+        cb(ab, userdata);
+    return ab;
+}
+
+sp_track *
+sp_artistbrowse_track(sp_artistbrowse * ab, int index)
+{
+    sp_album *album;
+    sp_track *track;
+
+    album = mocksp_album_create("fool-album", ab->artist, 2001,
+                        (byte *) "01234567890123456789", 1, 1, 1);
+    switch (index) {
+    case 0:
+        track = mocksp_track_create("foo", 1, &(album->artist), album,
+                            123, 0, 1, 1, SP_ERROR_OK, 1);
+        break;
+    case 1:
+        track = mocksp_track_create("bar", 1, &(album->artist), album,
+                            123, 0, 1, 2, SP_ERROR_OK, 1);
+        break;
+    case 2:
+        track = mocksp_track_create("baz", 1, &(album->artist), album,
+                            123, 0, 1, 3, SP_ERROR_OK, 1);
+        break;
+    default:
+        track = NULL;
+        break;
+    }
+    return track;
+}
+
+sp_album *
+sp_artistbrowse_album(sp_artistbrowse * ab, int index)
+{
+    sp_album *album;
+
+    switch (index) {
+    case 0:
+        album = mocksp_album_create("foo", ab->artist, 2001,
+                            (byte *) "01234567890123456789", 1, 1, 1);
+        break;
+    case 1:
+        album = mocksp_album_create("bar", ab->artist, 2002,
+                            (byte *) "01234567890123456789", 1, 1, 1);
+        break;
+    case 2:
+        album = mocksp_album_create("baz", ab->artist, 2003,
+                            (byte *) "01234567890123456789", 1, 1, 1);
+        break;
+    default:
+        album = NULL;
+        break;
+    }
+    return album;
+}
+
+int
+sp_artistbrowse_num_albums(sp_artistbrowse * ab)
+{
+    return 3;
+}
+
+int
+sp_artistbrowse_num_tracks(sp_artistbrowse * ab)
+{
+    return 3;
+}
+
+bool
+sp_artistbrowse_is_loaded(sp_artistbrowse * ab)
+{
+    return ab->loaded;
+}

data/src/error.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+const char*
+sp_error_message(sp_error error)
+{
+    char *buff = malloc(20 * sizeof(char));
+    sprintf(buff, "sp_error: %d", error);
+    return buff;
+}

data/src/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$CFLAGS << '-O0 -ggdb -Wextra'
+
+create_makefile 'libmockspotify'

data/src/image.c

@@ -0,0 +1,89 @@
+#include "libmockspotify.h"
+
+/*** MockSpotify API ***/
+sp_image*
+mocksp_image_create(const byte image_id[20], sp_imageformat format, size_t data_size, byte *data, sp_error error)
+{
+  sp_image *image = ALLOC(sp_image);
+  memcpy(image->image_id, image_id, 20);
+  image->format = format;
+  image->data_size = data_size;
+  image->data = ALLOC_N(byte, data_size + 1);
+  memcpy(image->data, data, data_size);
+  image->error = error;
+  return image;
+}
+
+/*** Spotify API ***/
+
+sp_image*
+sp_image_create_from_link(sp_session *session, sp_link *l)
+{
+  byte *real_id  = l->data + strlen("spotify:image:");
+  byte *image_id = ALLOC_N(byte, 20);
+  memcpy(image_id, real_id, 20);
+  return mocksp_image_create(image_id, SP_IMAGE_FORMAT_JPEG, 0, NULL, SP_ERROR_OK);
+}
+
+void
+sp_image_add_ref(sp_image *image)
+{
+}
+
+void
+sp_image_release(sp_image *image)
+{
+}
+
+bool
+sp_image_is_loaded(sp_image *i)
+{
+    return sp_image_error(i) == SP_ERROR_OK;
+}
+
+sp_imageformat
+sp_image_format(sp_image *i)
+{
+    return i->format;
+}
+
+sp_error
+sp_image_error(sp_image *i)
+{
+    return i->error;
+}
+
+const void *
+sp_image_data(sp_image *i, size_t *t)
+{
+    *t = i->data_size;
+    return i->data;
+}
+
+sp_image *
+sp_image_create(sp_session *session, const byte image_id[20])
+{
+    sp_image *image = ALLOC(sp_image);
+    memcpy(image->image_id, image_id, 20);
+    return image;
+}
+
+const byte*
+sp_image_image_id(sp_image *i)
+{
+  return i->image_id;
+}
+
+void
+sp_image_add_load_callback(sp_image *i, image_loaded_cb *callback,
+                           void *userdata)
+{
+    /* TODO */
+}
+
+void
+sp_image_remove_load_callback(sp_image *i, image_loaded_cb *callback,
+                              void *userdata)
+{
+    /* TODO */
+}