spotify 12.4.0 → 12.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf64e70f3fd55a846fc2a016a2948cf547e92f54
+  data.tar.gz: 1012f48eb4fcb112b5866d63defe433a0974e2bb
+SHA512:
+  metadata.gz: c6b782905e37db551e1291e1769508d5f0fa0d6f1c6932700b9c0bace51433228e558ea607d99937a6e2f5b26c2a0066e93e069c74a7b2878cd5f315f6c5d376
+  data.tar.gz: b402e97d8772d953ae453b7b1d61a3cd73ad9346f970b739adb23d97cc3740a0677c4c1c14845af482ace77434adef085333bb9b491ba70ee53e3dcb5a29d9f3

data/.travis.yml

@@ -1,3 +1,6 @@
 rvm:
   - 1.9.2
   - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+  - jruby-19mode

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 [HEAD][]
 -----------
+
+[v12.5.0][]
+-----------
+This release *also* breaks backwards-compatibilty, now all functions
+accepting structs also have type-safety protection, similar to what
+happens for pointers in v12.4.0.
+
+Additionally, gem now supports JRuby and Rubinius explicitly!
+
+- [a450bf27b9] implement type safety for all struct arguments
+- [44b35d6432] automatic release for Subscribers struct
+- [1c88809139] force application_key to be assigned as a string in SessionConfig
+- [c9bc974d44] Subscribers now always have a :subscribers member
+- [05e691c2aa] allow instantiating Subscribers from NULL
+- [c83c9feb1c] Enable rbx-19mode on travis-ci.org
+- [3e153a48f4] Enable jruby-19mode on travis-ci.org
+- [72aadf4906] Use UTF8 everywhere, even in struct fields
+- [e05b286118] Make Subscribers enumerable
+
+[v12.4.0][]
+-----------
 This release breaks backwards-compatibility, as functions will no
 longer accept pointers of any other type of what they expect. This
 means that you must wrap any pointers in a Spotify::ManagedPointer
@@ -164,8 +185,10 @@ v0.0.0
 ------
 - release to register rubygems.org name
 
-[HEAD]: https://github.com/Burgestrand/spotify/compare/v12.3.0...HEAD
+[HEAD]: https://github.com/Burgestrand/spotify/compare/v12.5.0...HEAD
 
+[v12.5.0]: https://github.com/Burgestrand/spotify/compare/v12.4.0...v12.5.0
+[v12.4.0]: https://github.com/Burgestrand/spotify/compare/v12.3.0...v12.4.0
 [v12.3.0]: https://github.com/Burgestrand/spotify/compare/v12.2.0...v12.3.0
 [v12.2.0]: https://github.com/Burgestrand/spotify/compare/v12.0.3...v12.2.0
 [v12.0.3]: https://github.com/Burgestrand/spotify/compare/v12.0.2...v12.0.3

data/Gemfile

@@ -3,5 +3,5 @@ gemspec
 
 gem 'pry'
 gem 'yard'
-gem 'redcarpet'
-gem "plaything", "~> 1.0"
+gem 'maruku'
+gem "plaything", "~> 1.1"

data/README.markdown

@@ -18,11 +18,13 @@ The Spotify gem has:
 - [Automatic garbage collection][]. Piggybacking on Ruby’s GC to manage pointer lifecycle.
 - [Parallell function call protection][]. libspotify is not thread-safe, but Spotify protects you.
 - [Type conversion and type safety][]. Special pointers for every Spotify type, protecting you from accidental mix-ups.
+- [Support for JRuby and Rubinius][]. Thanks to FFI, the gem runs fine on the main three Ruby implementations!
 
 [100% API coverage]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API
 [Automatic garbage collection]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/ManagedPointer
 [Parallell function call protection]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify#method_missing-class_method
 [Type conversion and type safety]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/ManagedPointer
+[Support for JRuby and Rubinius]: https://github.com/Burgestrand/spotify/blob/master/.travis.yml
 
 The Spotify gem is aimed at experienced developers
 --------------------------------------------------

data/examples/audio-stream.rb

@@ -50,8 +50,7 @@ class FrameReader
     @channels = channels
     @sample_type = sample_type
     @size = frames_count * @channels
-    # strip type information, we work with bytes
-    @pointer = FFI::Pointer.new(frames_ptr)
+    @pointer = FFI::Pointer.new(@sample_type, frames_ptr)
   end
 
   attr_reader :size
@@ -59,11 +58,10 @@ class FrameReader
   def each
     return enum_for(__method__) unless block_given?
 
-    ffi_read = :"get_#{@sample_type}"
-    ffi_size = FFI.type_size(@sample_type)
+    ffi_read = :"read_#{@sample_type}"
 
     (0...size).each do |index|
-      yield @pointer.public_send(ffi_read, index * ffi_size)
+      yield @pointer[index].public_send(ffi_read)
     end
   end
 end
@@ -118,8 +116,7 @@ $session_callbacks = {
       $logger.debug("session (player)") { "music delivery audio discontuity" }
     else
       frames = FrameReader.new(format[:channels], format[:sample_type], num_frames, frames)
-      consumed_samples = plaything << frames
-      consumed_frames = consumed_samples / format[:channels]
+      consumed_frames = plaything.stream(frames, format.to_h)
       $logger.debug("session (player)") { "music delivery #{consumed_frames} of #{num_frames}" }
       consumed_frames
     end
@@ -141,7 +138,7 @@ $session_callbacks = {
 # https://developer.spotify.com/technologies/libspotify/docs/12.1.45/structsp__session__config.html
 config = Spotify::SessionConfig.new({
   api_version: Spotify::API_VERSION.to_i,
-  application_key: IO.read("./spotify_appkey.key"),
+  application_key: IO.read("./spotify_appkey.key", encoding: "BINARY"),
   cache_location: ".spotify/",
   settings_location: ".spotify/",
   tracefile: "spotify_tracefile.txt",

data/examples/logging-in.rb

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
-require 'spotify'
-require 'logger'
+require "bundler/setup"
+require "spotify"
+require "logger"
 
 # We use a logger to print some information on when things are happening.
 $logger = Logger.new($stderr)
@@ -11,21 +12,14 @@ $logger = Logger.new($stderr)
 # Some utility.
 #
 
-# This method is just for convenience. Calling the process_events function
-# is slightly cumbersome.
-def process_events(session)
-  FFI::MemoryPointer.new(:int) do |ptr|
-    Spotify.session_process_events(session, ptr)
-    return Rational(ptr.read_int, 1000)
-  end
-end
-
 # libspotify supports callbacks, but they are not useful for waiting on
 # operations (how they fire can be strange at times, and sometimes they
 # might not fire at all). As a result, polling is the way to go.
 def poll(session)
   until yield
-    process_events(session)
+    FFI::MemoryPointer.new(:int) do |ptr|
+      Spotify.session_process_events(session, ptr)
+    end
     sleep(0.01)
   end
 end

data/lib/spotify/api/link.rb

@@ -1,7 +1,7 @@
 module Spotify
   class API
     # @!group Link
-    attach_function :link_create_from_string, [ :string ], Link
+    attach_function :link_create_from_string, [ UTF8String ], Link
     attach_function :link_create_from_track, [ Track, :int ], Link
     attach_function :link_create_from_album, [ Album ], Link
     attach_function :link_create_from_artist, [ Artist ], Link

data/lib/spotify/api/playlist.rb

@@ -2,8 +2,8 @@ module Spotify
   class API
     # @!group Playlist
     attach_function :playlist_is_loaded, [ Playlist ], :bool
-    attach_function :playlist_add_callbacks, [ Playlist, PlaylistCallbacks, :userdata ], :error
-    attach_function :playlist_remove_callbacks, [ Playlist, PlaylistCallbacks, :userdata ], :error
+    attach_function :playlist_add_callbacks, [ Playlist, PlaylistCallbacks.by_ref, :userdata ], :error
+    attach_function :playlist_remove_callbacks, [ Playlist, PlaylistCallbacks.by_ref, :userdata ], :error
     attach_function :playlist_num_tracks, [ Playlist ], :int
     attach_function :playlist_track, [ Playlist, :int ], Track
     attach_function :playlist_track_create_time, [ Playlist, :int ], :int
@@ -24,8 +24,8 @@ module Spotify
     attach_function :playlist_remove_tracks, [ Playlist, :array, :int ], :error
     attach_function :playlist_reorder_tracks, [ Playlist, :array, :int, :int ], :error
     attach_function :playlist_num_subscribers, [ Playlist ], :uint
-    attach_function :playlist_subscribers, [ Playlist ], Subscribers
-    attach_function :playlist_subscribers_free, [ Subscribers ], :error
+    attach_function :playlist_subscribers, [ Playlist ], Subscribers.auto_ptr
+    attach_function :playlist_subscribers_free, [ Subscribers.by_ref ], :error
     attach_function :playlist_update_subscribers, [ Session, Playlist ], :error
     attach_function :playlist_is_in_ram, [ Session, Playlist ], :bool
     attach_function :playlist_set_in_ram, [ Session, Playlist, :bool ], :error

data/lib/spotify/api/playlist_container.rb

@@ -1,8 +1,8 @@
 module Spotify
   class API
     # @!group PlaylistContainer
-    attach_function :playlistcontainer_add_callbacks, [ PlaylistContainer, PlaylistContainerCallbacks, :userdata ], :error
-    attach_function :playlistcontainer_remove_callbacks, [ PlaylistContainer, PlaylistContainerCallbacks, :userdata ], :error
+    attach_function :playlistcontainer_add_callbacks, [ PlaylistContainer, PlaylistContainerCallbacks.by_ref, :userdata ], :error
+    attach_function :playlistcontainer_remove_callbacks, [ PlaylistContainer, PlaylistContainerCallbacks.by_ref, :userdata ], :error
     attach_function :playlistcontainer_num_playlists, [ PlaylistContainer ], :int
     attach_function :playlistcontainer_playlist, [ PlaylistContainer, :int ], Playlist
     attach_function :playlistcontainer_playlist_type, [ PlaylistContainer, :int ], :playlist_type

data/lib/spotify/api/session.rb

@@ -1,10 +1,10 @@
 module Spotify
   class API
     # @!group Session
-    attach_function :session_create, [ SessionConfig, :buffer_out ], :error
+    attach_function :session_create, [ SessionConfig.by_ref, :buffer_out ], :error
     attach_function :session_release, [ Session ], :error
     attach_function :session_process_events, [ Session, :buffer_out ], :error
-    attach_function :session_login, [ Session, UTF8String, :string, :bool, :string ], :error
+    attach_function :session_login, [ Session, UTF8String, UTF8String, :bool, UTF8String ], :error
     attach_function :session_relogin, [ Session ], :error
     attach_function :session_forget_me, [ Session ], :error
     attach_function :session_remembered_user, [ Session, :buffer_out, :size_t ], :int
@@ -28,19 +28,19 @@ module Spotify
     attach_function :session_set_connection_rules, [ Session, :connection_rules ], :error
     attach_function :offline_tracks_to_sync, [ Session ], :int
     attach_function :offline_num_playlists, [ Session ], :int
-    attach_function :offline_sync_get_status, [ Session, OfflineSyncStatus ], :bool
+    attach_function :offline_sync_get_status, [ Session, OfflineSyncStatus.by_ref ], :bool
     attach_function :offline_time_left, [ Session ], :int
     attach_function :session_user_country, [ Session ], :int
     attach_function :session_preferred_offline_bitrate, [ Session, :bitrate, :bool ], :error
     attach_function :session_set_volume_normalization, [ Session, :bool ], :error
     attach_function :session_get_volume_normalization, [ Session ], :bool
     attach_function :session_flush_caches, [ Session ], :error
-    attach_function :session_user_name, [ Session ], :string
+    attach_function :session_user_name, [ Session ], UTF8String
     attach_function :session_set_private_session, [ Session, :bool ], :error
     attach_function :session_is_private_session, [ Session ], :bool
     attach_function :session_set_scrobbling, [ Session, :social_provider, :scrobbling_state ], :error
     attach_function :session_is_scrobbling, [ Session, :social_provider, :buffer_out ], :error
     attach_function :session_is_scrobbling_possible, [ Session, :social_provider, :buffer_out ], :error
-    attach_function :session_set_social_credentials, [ Session, :social_provider, UTF8String, :string ], :error
+    attach_function :session_set_social_credentials, [ Session, :social_provider, UTF8String, UTF8String ], :error
   end
 end

data/lib/spotify/managed_pointer.rb

@@ -15,6 +15,8 @@ module Spotify
   #
   # @api private
   class ManagedPointer < FFI::AutoPointer
+    extend Spotify::TypeSafety
+
     class << self
       # Releases the given pointer if it is not null.
       #
@@ -24,7 +26,7 @@ module Spotify
       def release(pointer)
         unless pointer.null?
           # this is to circumvent the type protection
-          pointer = base_class.new(pointer)
+          pointer = type_class.new(pointer)
           pointer.autorelease = false
 
           $stderr.puts "Spotify.#{type}_release(#{pointer.inspect})" if $DEBUG
@@ -36,7 +38,7 @@ module Spotify
       #
       # This method derives the retain method from the class name.
       #
-      # @param [self] pointer must be an instance of {#base_class}
+      # @param [self] pointer must be an instance of {#type_class}
       def retain(pointer)
         unless pointer.null?
           $stderr.puts "Spotify.#{type}_add_ref(#{pointer.inspect})" if $DEBUG
@@ -49,13 +51,17 @@ module Spotify
       def to_native(value, ctx)
         if value.nil? or value.null?
           raise TypeError, "#{name} pointers cannot be null, was #{value.inspect}"
-        elsif value.kind_of?(base_class)
-          super
         else
-          raise TypeError, "expected a kind of #{name}, was #{value.class}"
+          super
         end
       end
 
+      # @see https://github.com/jruby/jruby/issues/607
+      # @return [Integer] size of the native type, defined for JRuby.
+      def size
+        FFI.type_size(:pointer)
+      end
+
       # Retaining class is needed for the functions that return a pointer that
       # does not have its reference count increased. This class is a subclass
       # of the ManagedPointer, and should behave the same in all circumstances
@@ -79,7 +85,7 @@ module Spotify
 
               protected
 
-              def base_class
+              def type_class
                 superclass
               end
             end
@@ -101,13 +107,6 @@ module Spotify
       def type
         name.split('::')[-1].downcase
       end
-
-      # Retrieves the base class for this pointer. This is overridden
-      # by the {.retaining_class}. It is used for type-checking inside
-      # {.to_native}.
-      def base_class
-        self
-      end
     end
 
     # @return [String] string representation of self.

data/lib/spotify/objects.rb

@@ -1,3 +1,4 @@
+require 'spotify/type_safety'
 require 'spotify/managed_pointer'
 
 require 'spotify/objects/album'

data/lib/spotify/structs.rb

@@ -3,6 +3,8 @@ module Spotify
   # checking that happens in the Spotify::API namespace, and
   # it also allows you to initialize structs with a hash.
   class Struct < FFI::Struct
+    extend Spotify::TypeSafety
+
     # This is used by FFI to do type lookups when creating the
     # struct layout. By overriding this we can trick FFI into
     # looking up types in the right location.

data/lib/spotify/structs/session_config.rb

@@ -20,22 +20,22 @@ module Spotify
   class SessionConfig < Spotify::Struct
     it = {}
     it[:api_version] = :int
-    it[:cache_location] = NULString
-    it[:settings_location] = NULString
-    it[:application_key] = :pointer
+    it[:cache_location] = UTF8StringPointer
+    it[:settings_location] = UTF8StringPointer
+    it[:application_key] = ByteString
     it[:application_key_size] = :size_t
-    it[:user_agent] = NULString
+    it[:user_agent] = UTF8StringPointer
     it[:callbacks] = SessionCallbacks.by_ref
     it[:userdata] = :userdata
     it[:compress_playlists] = :bool
     it[:dont_save_metadata_for_playlists] = :bool
     it[:initially_unload_playlists] = :bool
-    it[:device_id] = NULString
-    it[:proxy] = NULString
-    it[:proxy_username] = NULString
-    it[:proxy_password] = NULString
-    it[:ca_certs_filename] = NULString if Spotify::API.linux?
-    it[:tracefile] = NULString
+    it[:device_id] = UTF8StringPointer
+    it[:proxy] = UTF8StringPointer
+    it[:proxy_username] = UTF8StringPointer
+    it[:proxy_password] = UTF8StringPointer
+    it[:ca_certs_filename] = UTF8StringPointer if Spotify::API.linux?
+    it[:tracefile] = UTF8StringPointer
     layout(it)
 
     # Overridden for some keys for convenience.
@@ -49,14 +49,8 @@ module Spotify
     def []=(key, value)
       case key
       when :application_key
-        if value.is_a?(String)
-          pointer = FFI::MemoryPointer.new(:char, value.bytesize)
-          pointer.write_string(value)
-          super(key, pointer)
-          self[:application_key_size] = pointer.size
-        else
-          super
-        end
+        super(key, value)
+        self[:application_key_size] = value.bytesize if value
       else super
       end
     end

data/lib/spotify/structs/subscribers.rb

@@ -1,11 +1,29 @@
 module Spotify
   # Spotify::Struct for Subscribers of a Playlist.
   #
+  # Memory looks like this:
+  #   00 00 00 00 <- count of subscribers
+  #   00 00 00 00 <- pointer to subscriber 1
+  #   …… …… …… ……
+  #   00 00 00 00 <- pointer to subscriber n
+  #
   # @attr [Fixnum] count
   # @attr [Array<Pointer<String>>] subscribers
   class Subscribers < Spotify::Struct
+    include Enumerable
+
+    class << self
+      def release(pointer)
+        unless pointer.null?
+          pointer = type_class.new(pointer)
+          $stderr.puts "Spotify.playlist_subscribers_free(#{pointer.inspect})" if $DEBUG
+          Spotify.playlist_subscribers_free(pointer)
+        end
+      end
+    end
+
     layout :count => :uint,
-           :subscribers => [:pointer, 1] # array of pointers to strings
+           :subscribers => [UTF8StringPointer, 0] # array of pointers to strings
 
     # Redefined, as the layout of the Struct can only be determined
     # at run-time.
@@ -13,18 +31,43 @@ module Spotify
     # @param [FFI::Pointer, Integer] pointer_or_count
     def initialize(pointer_or_count)
       count = if pointer_or_count.is_a?(FFI::Pointer)
-        pointer_or_count.read_uint
+        if pointer_or_count.null?
+          0
+        else
+          pointer_or_count.read_uint
+        end
       else
         pointer_or_count
       end
 
       layout  = [:count, :uint]
-      layout += [:subscribers, [:pointer, count]] if count > 0
+      layout += [:subscribers, [UTF8StringPointer, count]]
 
       if pointer_or_count.is_a?(FFI::Pointer)
         super(pointer_or_count, *layout)
       else
         super(nil, *layout)
+        self[:count] = count
+      end
+    end
+
+    # Yields every subscriber as a UTF8-encoded string.
+    #
+    # @yield [subscriber]
+    # @yieldparam [String] subscriber
+    def each
+      return enum_for(__method__) { count } unless block_given?
+      count.times { |index| yield self[:subscribers][index] }
+    end
+
+    private
+
+    # @return [Integer] number of subscribers in the struct.
+    def count
+      if null?
+        0
+      else
+        self[:count]
       end
     end
   end

data/lib/spotify/type_safety.rb

@@ -0,0 +1,25 @@
+module Spotify
+  module TypeSafety
+    # Convert given value to native value, with type checking.
+    #
+    # @note Calls super-implementation if type is safe.
+    #
+    # @param value
+    # @param ctx
+    # @raise [TypeError] if value is not of the same kind as {#type_class}.
+    def to_native(value, ctx)
+      if value.kind_of?(type_class)
+        super
+      else
+        raise TypeError, "expected a kind of #{name}, was #{value.class}"
+      end
+    end
+
+    # Retrieve the type that all objects going into to_native must be of.
+    #
+    # @return self by default
+    def type_class
+      self
+    end
+  end
+end

data/lib/spotify/types.rb

@@ -1,3 +1,4 @@
 require 'spotify/types/utf8_string'
+require 'spotify/types/utf8_string_pointer'
 require 'spotify/types/image_id'
-require 'spotify/types/nul_string'
+require 'spotify/types/byte_string'

data/lib/spotify/types/byte_string.rb

@@ -0,0 +1,28 @@
+module Spotify
+  module ByteString
+    extend FFI::DataConverter
+    native_type FFI::Type::POINTER
+
+    class << self
+      # Given either a String or nil, make an actual FFI::Pointer
+      # of that value, without an ending NULL-byte.
+      #
+      # @param [#to_str, nil] value
+      # @param ctx
+      # @return [FFI::Pointer]
+      def to_native(value, ctx)
+        value && begin
+          value = value.to_str
+
+          pointer = FFI::MemoryPointer.new(:char, value.bytesize)
+          pointer.write_string(value)
+        end
+      end
+
+      # @see NulString.reference_required?
+      def reference_required?
+        true
+      end
+    end
+  end
+end

data/lib/spotify/types/{nul_string.rb → utf8_string_pointer.rb}

@@ -4,7 +4,7 @@ module Spotify
   #
   # Keep in mind this implementation is unsafe to use on Rubinius
   # as long as it ignores the .reference_required? indication.
-  module NULString
+  module UTF8StringPointer
     extend FFI::DataConverter
     native_type FFI::Type::POINTER
 
@@ -16,7 +16,7 @@ module Spotify
       # @param ctx
       # @return [FFI::Pointer]
       def to_native(value, ctx)
-        value && FFI::MemoryPointer.from_string(value.to_str)
+        value && FFI::MemoryPointer.from_string(value.to_str.encode("UTF-8"))
       end
 
       # Given a pointer, read out it’s string.
@@ -25,7 +25,7 @@ module Spotify
       # @param ctx
       # @return [String, nil]
       def from_native(value, ctx)
-        value.read_string unless value.null?
+        value.read_string.force_encoding("UTF-8") unless value.null?
       end
 
       # Used by FFI::StructLayoutField to know if this field

data/lib/spotify/version.rb

@@ -1,7 +1,7 @@
 module Spotify
   # @note See README for versioning policy.
   # @return [String] Spotify gem version.
-  VERSION = '12.4.0'
+  VERSION = '12.5.0'
 
   # @return [String] Compatible libspotify API version.
   API_VERSION = '12.1.51'

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
 # encoding: utf-8
-require 'rbgccxml'
-require 'rspec'
-require 'pry'
+require "rbgccxml"
+require "rspec"
+require "pry"
 
-require 'spec/support/hook_spotify'
-require 'spec/support/spotify_util'
+require "spec/support/hook_spotify"
+require "spec/support/spotify_util"
 
 # You can pregenerate new XML files through:
 # gccxml spec/api-mac.h -fxml=spec/api-mac.xml
@@ -17,4 +17,14 @@ RSpec.configure do |config|
   def api
     Spotify::API
   end
+
+  config.filter_run_excluding(engine: ->(engine) do
+    ! Array(engine).include?(RUBY_ENGINE)
+  end)
+
+  config.filter_run_excluding(ruby_version: ->(requirement) do
+    ruby_version = Gem::Version.new(RUBY_VERSION)
+    required_version = Gem::Requirement.new(requirement)
+    ! required_version.satisfied_by?(ruby_version)
+  end)
 end

data/spec/spotify/managed_pointer_spec.rb

@@ -68,7 +68,18 @@ describe Spotify::ManagedPointer do
     end
   end
 
-  describe "garbage collection" do
+  describe ".size" do
+    it "returns the size of a pointer" do
+      Spotify::ManagedPointer.size.should eq FFI.type_size(:pointer)
+    end
+  end
+
+  # We only test this on MRI, since it does not work in quite
+  # the same way on JRuby nor Rubinius with regards to the GC.
+  #
+  # Luckily, if it works on MRI, we should be able to assume
+  # that it works on JRuby and Rubinius too.
+  describe "garbage collection", :engine => "ruby" do
     module Spotify
       class << API
         def bogus_add_ref(pointer)

data/spec/spotify/structs/session_config_spec.rb

@@ -13,8 +13,8 @@ describe Spotify::SessionConfig do
     config[:application_key].read_string(5).should eq "h\x00e\x00y"
   end
 
-  it "does not automatically set application key size when setting application key from pointer" do
+  it "does not support setting application key with a pointer" do
     expect { config[:application_key] = FFI::MemoryPointer.from_string("yay") }
-      .to_not change { config[:application_key_size] }
+      .to raise_error(NoMethodError, /to_str/)
   end
 end

data/spec/spotify/structs/struct_spec.rb

@@ -2,8 +2,8 @@ describe Spotify::Struct do
   let(:klass) do
     Class.new(Spotify::Struct) do
       layout :api_version => :int,
-             :cache_location => Spotify::NULString,
-             :user_agent => Spotify::NULString,
+             :cache_location => Spotify::UTF8StringPointer,
+             :user_agent => Spotify::UTF8StringPointer,
              :compress_playlists => :bool
     end
   end

data/spec/spotify/structs/subscribers_spec.rb

@@ -1,31 +1,115 @@
 describe Spotify::Subscribers do
-  it "should create the subscribers array using count" do
-    # Memory looks like this:
-    #
-    # 00 00 00 00 <- count of subscribers
-    # 00 00 00 00 <- pointer to subscriber 1
-    # …… …… …… ……
-    # 00 00 00 00 <- pointer to subscriber n
-    real_struct = Spotify::Subscribers.new(2)
-    real_struct[:count] = 2
-    real_struct[:subscribers][0] = FFI::MemoryPointer.from_string("a")
-    real_struct[:subscribers][1] = FFI::MemoryPointer.from_string("bb")
-
-    struct = Spotify::Subscribers.new(real_struct.pointer)
-    struct[:count].should eq 2
-    struct[:subscribers].size.should eq 2
-    struct[:subscribers][0].read_string.should eq "a"
-    struct[:subscribers][1].read_string.should eq "bb"
-    expect { struct[:subscribers][2] }.to raise_error(IndexError)
+  describe "#initialize" do
+    context "given a null pointer" do
+      subject(:subscribers) do
+        Spotify::Subscribers.new(FFI::Pointer::NULL)
+      end
+
+      it "is null" do
+        should be_null
+      end
+
+      it "protects against referencing non-allocated memory" do
+        expect { subscribers[:count] }.to raise_error(FFI::NullPointerError)
+      end
+
+      it "is empty" do
+        subscribers.to_a.should be_empty
+      end
+    end
+
+    context "given an empty struct pointer" do
+      let(:memory) do
+        pointer = FFI::MemoryPointer.new(:uint)
+        pointer.write_uint(0)
+        pointer
+      end
+
+      subject(:subscribers) do
+        pointer = FFI::Pointer.new(memory.address)
+        Spotify::Subscribers.new(pointer)
+      end
+
+      specify do
+        subscribers[:count].should be_zero
+      end
+
+      it "is empty" do
+        subscribers.to_a.should be_empty
+      end
+    end
+
+    context "given a filled struct pointer" do
+      let(:memory) do
+        klass = Class.new(Spotify::Struct) do
+          layout count: :uint,
+                 a: Spotify::UTF8StringPointer,
+                 b: Spotify::UTF8StringPointer
+        end
+
+        klass.new.tap do |struct|
+          struct[:count] = 2
+          struct[:a] = "Alpha"
+          struct[:b] = "Beta"
+        end
+      end
+
+      subject(:subscribers) do
+        Spotify::Subscribers.new(memory.pointer)
+      end
+
+      it "has the correct count" do
+        subscribers[:count].should eq 2
+      end
+
+      it "contains the subscribers" do
+        subscribers[:subscribers][0].should eq "Alpha"
+        subscribers[:subscribers][1].should eq "Beta"
+      end
+    end
+
+    context "given an integer count" do
+      subject(:subscribers) do
+        Spotify::Subscribers.new(2)
+      end
+
+      it "allocates memory for a `count` sized subscribers" do
+        subscribers[:subscribers].size.should eq 2
+      end
+
+      it "assigns count to the correct count" do
+        subscribers[:count].should eq 2
+      end
+    end
+  end
+
+  describe "#[:subscribers]" do
+    it "raises an error when referencing a value out of bounds" do
+      subscribers = Spotify::Subscribers.new(2)
+      expect { subscribers[:subscribers][2] }.to raise_error(IndexError)
+    end
   end
 
+  describe "#each" do
+    subject(:subscribers) do
+      Spotify::Subscribers.new(3).tap do |struct|
+        struct[:count] = 3
+        struct[:subscribers][0] = "Alpha"
+        struct[:subscribers][1] = "Beta"
+        struct[:subscribers][2] = "Gamma"
+      end
+    end
 
-  it "should not fail given an empty subscribers struct" do
-    subscribers = FFI::MemoryPointer.new(:uint)
-    subscribers.write_uint(0)
+    it "returns an enumerator with a defined size when not given a block", :ruby_version => ">= 2.0.0" do
+      enumerator = subscribers.each
+      enumerator.should be_a Enumerator
+      enumerator.size.should eq 3
+    end
 
-    subject = Spotify::Subscribers.new(subscribers)
-    subject[:count].should eq 0
-    expect { subject[:subscribers] }.to raise_error(ArgumentError)
+    it "yields every subscriber as an UTF-8 encoded string" do
+      strings = subscribers.to_a
+      strings.should eq %w[Alpha Beta Gamma]
+      strings.map(&:encoding).uniq.should eq [Encoding::UTF_8]
+    end
   end
 end

data/spec/spotify/type_safety_spec.rb

@@ -0,0 +1,36 @@
+describe Spotify::TypeSafety do
+  let(:superklass) do
+    Class.new do
+      def self.to_native(value, ctx)
+        value
+      end
+    end
+  end
+
+  let(:klass) do
+    Class.new(superklass) do
+      extend Spotify::TypeSafety
+
+      def self.type_class
+        self
+      end
+    end
+  end
+
+  describe "#to_native" do
+    it "calls to the superclass if value is accepted" do
+      value = klass.new
+      klass.to_native(value, nil).should eq value
+    end
+
+    it "raises a type error if the value is of the wrong type" do
+      expect { klass.to_native(Object.new, nil) }.to raise_error(TypeError, /expected a kind of/)
+    end
+  end
+
+  describe "#type_class" do
+    it "defaults to the class itself" do
+      klass.type_class.should eq klass
+    end
+  end
+end

data/spec/spotify/types/byte_string_spec.rb

@@ -0,0 +1,26 @@
+describe Spotify::ByteString do
+  describe ".to_native" do
+    it "returns a memory pointer containing the given string, without ending NULL byte" do
+      pointer = Spotify::ByteString.to_native("coolio", nil)
+      pointer.size.should eq 6
+    end
+
+    it "returns nil when given nil" do
+      pointer = Spotify::ByteString.to_native(nil, nil)
+      pointer.should be_nil
+    end
+
+    it "raises an error when given a non-string" do
+      expect { Spotify::ByteString.to_native({}, nil) }
+        .to raise_error(NoMethodError, /to_str/)
+    end
+  end
+
+  describe ".from_native" do
+    it "returns the value, there is no size information" do
+      pointer = FFI::MemoryPointer.from_string("hey")
+      value = Spotify::ByteString.from_native(pointer, nil)
+      value.should eql pointer
+    end
+  end
+end

data/spec/spotify/types/utf8_string_pointer_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+describe Spotify::UTF8StringPointer do
+  describe ".to_native" do
+    it "returns a memory pointer containing the given string" do
+      pointer = Spotify::UTF8StringPointer.to_native("coolio", nil)
+      pointer.read_string.should eq "coolio"
+    end
+
+    it "returns nil when given nil" do
+      pointer = Spotify::UTF8StringPointer.to_native(nil, nil)
+      pointer.should be_nil
+    end
+
+    it "converts strings to UTF-8" do
+      string = "åäö".encode("ISO-8859-1")
+      pointer = Spotify::UTF8StringPointer.to_native(string, nil)
+
+      string.bytesize.should eq 3
+      pointer.read_string.bytesize.should eq 6
+    end
+
+    it "raises an error when given a non-string" do
+      expect { Spotify::UTF8StringPointer.to_native({}, nil) }
+        .to raise_error(NoMethodError, /to_str/)
+    end
+  end
+
+  describe ".from_native" do
+    it "returns an empty string if given a null pointer" do
+      value = Spotify::UTF8StringPointer.from_native(FFI::Pointer::NULL, nil)
+      value.should be_nil
+    end
+
+    it "returns the string value of the string pointer" do
+      pointer = FFI::MemoryPointer.from_string("hey")
+      value = Spotify::UTF8StringPointer.from_native(pointer, nil)
+      value.should eq "hey"
+    end
+
+    it "forces the encoding to UTF-8" do
+      string = FFI::MemoryPointer.from_string("åäö".encode("ISO-8859-1"))
+
+      value = Spotify::UTF8StringPointer.from_native(string, nil)
+      value.bytesize.should eq 3
+      value.encoding.should eq Encoding::UTF_8
+      value.should_not be_valid_encoding
+    end
+  end
+end

data/spec/support/spotify_util.rb

@@ -3,6 +3,8 @@ module Spotify
   def self.resolve_type(type)
     if type.is_a?(Class) and type <= Spotify::ManagedPointer
       type
+    elsif type.respond_to?(:native_type)
+      type.native_type
     else
       type = Spotify::API.find_type(type)
       type = type.type if type.respond_to?(:type)

metadata

@@ -1,102 +1,91 @@
 --- !ruby/object:Gem::Specification
 name: spotify
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 12.4.0
+  version: 12.5.0
 platform: ruby
 authors:
 - Kim Burgestrand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-26 00:00:00.000000000 Z
+date: 2013-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.11
-    none: false
+  type: :runtime
   prerelease: false
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.11
-    none: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 12.1.51
-    none: false
-  prerelease: false
   name: libspotify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 12.1.51
-    none: false
   type: :runtime
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  prerelease: false
+        version: 12.1.51
+- !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
+- !ruby/object:Gem::Dependency
   name: rbgccxml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
+- !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - kim@burgestrand.se
@@ -161,10 +150,12 @@ files:
 - lib/spotify/structs/session_callbacks.rb
 - lib/spotify/structs/session_config.rb
 - lib/spotify/structs/subscribers.rb
+- lib/spotify/type_safety.rb
 - lib/spotify/types.rb
+- lib/spotify/types/byte_string.rb
 - lib/spotify/types/image_id.rb
-- lib/spotify/types/nul_string.rb
 - lib/spotify/types/utf8_string.rb
+- lib/spotify/types/utf8_string_pointer.rb
 - lib/spotify/util.rb
 - lib/spotify/version.rb
 - spec/bench_helper.rb
@@ -181,8 +172,10 @@ files:
 - spec/spotify/structs/struct_spec.rb
 - spec/spotify/structs/subscribers_spec.rb
 - spec/spotify/structs_spec.rb
+- spec/spotify/type_safety_spec.rb
+- spec/spotify/types/byte_string_spec.rb
 - spec/spotify/types/image_id_spec.rb
-- spec/spotify/types/nul_string_spec.rb
+- spec/spotify/types/utf8_string_pointer_spec.rb
 - spec/spotify/types/utf8_string_spec.rb
 - spec/support/api-linux.h
 - spec/support/api-linux.xml
@@ -196,30 +189,26 @@ files:
 homepage: https://github.com/Burgestrand/spotify
 licenses:
 - X11 License
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '1.9'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -321866255872055088
-  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Low-level Ruby bindings for libspotify
 test_files:
 - spec/bench_helper.rb
@@ -236,8 +225,10 @@ test_files:
 - spec/spotify/structs/struct_spec.rb
 - spec/spotify/structs/subscribers_spec.rb
 - spec/spotify/structs_spec.rb
+- spec/spotify/type_safety_spec.rb
+- spec/spotify/types/byte_string_spec.rb
 - spec/spotify/types/image_id_spec.rb
-- spec/spotify/types/nul_string_spec.rb
+- spec/spotify/types/utf8_string_pointer_spec.rb
 - spec/spotify/types/utf8_string_spec.rb
 - spec/support/api-linux.h
 - spec/support/api-linux.xml

data/spec/spotify/types/nul_string_spec.rb

@@ -1,31 +0,0 @@
-describe Spotify::NULString do
-  describe ".to_native" do
-    it "returns a memory pointer containing the given string" do
-      pointer = Spotify::NULString.to_native("coolio", nil)
-      pointer.read_string.should eq "coolio"
-    end
-
-    it "returns nil when given nil" do
-      pointer = Spotify::NULString.to_native(nil, nil)
-      pointer.should be_nil
-    end
-
-    it "raises an error when given a non-string" do
-      expect { Spotify::NULString.to_native({}, nil) }
-        .to raise_error(NoMethodError, /to_str/)
-    end
-  end
-
-  describe ".from_native" do
-    it "returns an empty string if given a null pointer" do
-      value = Spotify::NULString.from_native(FFI::Pointer::NULL, nil)
-      value.should be_nil
-    end
-
-    it "returns the string value of the string pointer" do
-      pointer = FFI::MemoryPointer.from_string("hey")
-      value = Spotify::NULString.from_native(pointer, nil)
-      value.should eq "hey"
-    end
-  end
-end