hallon 0.11.0 → 0.12.0

data/lib/hallon/observable/toplist.rb

@@ -0,0 +1,30 @@
+module Hallon::Observable
+  # Callbacks related to the {Hallon::Toplist} object.
+  module Toplist
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] load callback
+    def initialize_callbacks
+      callback_for(:load)
+    end
+
+    # This callback is fired when the Image object is fully loaded.
+    #
+    # @example listening to this callback
+    #   toplist.on(:load) do
+    #     puts "the toplist has loaded!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Toplist] self
+    def load_callback(pointer, userdata)
+      trigger(pointer, :load)
+    end
+  end
+end
+

data/lib/hallon/player.rb

@@ -3,12 +3,11 @@ module Hallon
   # A wrapper around Session for playing, stopping and otherwise
   # controlling the playback features of libspotify.
   #
-  # @note This is very much a work in progress. Given Session still
-  #       takes care of all callbacks, and the callbacks themselves
-  #       must still be handled by means of Ruby FFI.
+  # @note This is very much a work in progress.
   # @see Session
   class Player
-    include Observable
+    # meep?
+    extend Observable::Player
 
     # @return [Spotify::Pointer<Session>] session pointer
     attr_reader :pointer
@@ -25,7 +24,7 @@ module Hallon
     #
     # @example
     #   Hallon::Player.new(session) do
-    #     on(:music_delivery) do |*frames|
+    #     on(:music_delivery) do |format, frames|
     #     end
     #
     #     on(:start_playback) do
@@ -56,20 +55,12 @@ module Hallon
       @session = session
       @pointer = @session.pointer
 
-      %w[start_playback stop_playback play_token_lost end_of_track streaming_error].each do |cb|
+      %w[
+        start_playback stop_playback play_token_lost end_of_track
+        streaming_error get_audio_buffer_stats music_delivery
+      ].each do |cb|
         @session.on(cb) { |*args| trigger(cb, *args) }
       end
-
-      @session.on(:audio_buffer_stats) do |stats_ptr|
-        stats = Spotify::AudioBufferStats.new(stats_ptr)
-        samples, dropouts = trigger(:buffer_size?)
-        stats[:samples]  = samples || 0
-        stats[:dropouts] = dropouts || 0
-      end
-
-      @session.on(:music_delivery) do |format, frames, num_frames|
-        trigger(:music_delivery, format, frames, num_frames)
-      end
     end
 
     # Set preferred playback bitrate.

data/lib/hallon/playlist.rb

@@ -6,9 +6,6 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__playlist.html
   class Playlist < Base
-    include Observable
-    extend Linkable
-
     # Playlist::Track is a {Track} with additional information attached to it,
     # that is specific to the playlist it was created from. The returned track
     # is a snapshot of the information, so even if the underlying track moves,
@@ -80,6 +77,11 @@ module Hallon
       end
     end
 
+    extend Linkable
+
+    # CAN HAZ CALLBAKZ
+    extend Observable::Playlist
+
     from_link :playlist do |pointer|
       Spotify.playlist_create!(session.pointer, pointer)
     end
@@ -92,8 +94,10 @@ module Hallon
     def initialize(link)
       @pointer = to_pointer(link, :playlist)
 
-      callbacks = Spotify::PlaylistCallbacks.create(self, @sp_callbacks = {})
-      Spotify.playlist_add_callbacks(pointer, callbacks, nil)
+      subscribe_for_callbacks do |callbacks|
+        Spotify.playlist_remove_callbacks(pointer, callbacks, nil)
+        Spotify.playlist_add_callbacks(pointer, callbacks, nil)
+      end
     end
 
     # @return [Boolean] true if the playlist is loaded
@@ -167,8 +171,8 @@ module Hallon
     def name=(name)
       name = name.to_s.encode('UTF-8')
 
-      unless name.length < 256
-        raise ArgumentError, "name must be shorter than 256 characters (UTF-8)"
+      unless name.bytesize < 256
+        raise ArgumentError, "name must be shorter than 256 bytes"
       end
 
       unless name =~ /[^ ]/u

data/lib/hallon/playlist_container.rb

@@ -64,6 +64,11 @@ module Hallon
         end if other.is_a?(Folder)
       end
 
+      # @return [Enumerator<Playlist, Folder>] contents of this folder
+      def contents
+        container.contents[(@begin + 1)..(@end - 1)]
+      end
+
       # @return [Boolean] true if the folder has moved.
       def moved?
         Spotify.playlistcontainer_playlist_folder_id(container.pointer, @begin) != id or
@@ -71,7 +76,7 @@ module Hallon
       end
     end
 
-    include Observable
+    extend Observable::PlaylistContainer
 
     # Wrap an existing PlaylistContainer pointer in an object.
     #
@@ -79,8 +84,10 @@ module Hallon
     def initialize(pointer)
       @pointer = to_pointer(pointer, :playlistcontainer)
 
-      callbacks = Spotify::PlaylistContainerCallbacks.create(self, @sp_callbacs = {})
-      Spotify.playlistcontainer_add_callbacks(pointer, callbacks, nil)
+      subscribe_for_callbacks do |callbacks|
+        Spotify.playlistcontainer_remove_callbacks(pointer, callbacks, nil)
+        Spotify.playlistcontainer_add_callbacks(pointer, callbacks, nil)
+      end
     end
 
     # @return [Boolean] true if the container is loaded.
@@ -224,7 +231,7 @@ module Hallon
     # @return [Boolean] true if the operation can be performed
     def can_move?(from, to)
       error = move_playlist(from, to, true)
-      number, symbol = Error.disambiguate(error)
+      _, symbol = Error.disambiguate(error)
       symbol == :ok
     end
 

data/lib/hallon/queue.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+require 'thread'
+
+module Hallon
+  # Hallon::Queue is a non-blocking (well, not entirely) sized FIFO queue.
+  #
+  # You initialize the queue with a `max_size`, and then push data to it.
+  # For every push operation, the Queue will tell you how much of your data
+  # it could consume. If the queue becomes full, it won’t accept any more
+  # data (and will return 0 on the #push operation) until you pull some data
+  # out of it with #pop.
+  #
+  # Hallon::Queue is useful for handling {Hallon::Observable::Session#music_delivery_callback}.
+  #
+  # @example
+  #   queue = Hallon::Queue.new(4)
+  #   queue.push([1, 2]) # => 2
+  #   queue.push([3]) # => 1
+  #   queue.push([4, 5, 6]) # => 1
+  #   queue.push([5, 6]) # => 0
+  #   queue.pop(1) # => [1]
+  #   queue.push([5, 6]) # => 1
+  #   queue.pop # => [2, 3, 4, 5]
+  class Queue
+    attr_reader :max_size
+
+    # @param [Integer] max_size
+    def initialize(max_size)
+      @mutex    = Mutex.new
+      @condv    = ConditionVariable.new
+
+      @max_size = max_size
+      @samples  = []
+    end
+
+    # @param [#take] data
+    # @return [Integer] how much of the data that was added to the queue
+    def push(samples)
+      synchronize do
+        can_accept  = max_size - size
+        new_samples = samples.take(can_accept)
+
+        @samples.concat(new_samples)
+        @condv.signal
+
+        new_samples.size
+      end
+    end
+
+    # @note If the queue is empty, this operation will block until data is available.
+    # @param [Integer] num_samples max number of samples to pop off the queue
+    # @return [Array] data, where data.size might be less than num_samples but never more
+    def pop(num_samples = max_size)
+      synchronize do
+        @condv.wait(@mutex) while @samples.empty?
+        @samples.shift(num_samples)
+      end
+    end
+
+    # @return [Integer] number of samples in buffer
+    def size
+      @samples.size
+    end
+
+    private
+      # @yield (merely a wrapper over @mutex.synchronize)
+      def synchronize
+        @mutex.synchronize { return yield }
+      end
+  end
+end

data/lib/hallon/search.rb

@@ -5,7 +5,7 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__search.html
   class Search < Base
-    include Observable
+    extend Observable::Search
 
     # @return [Array<Symbol>] a list of radio genres available for search
     def self.genres
@@ -35,10 +35,11 @@ module Hallon
 
       search = allocate
       search.instance_eval do
-        @callback = proc { search.trigger(:load) }
-        @pointer   = Spotify.radio_search_create!(session.pointer, from_year, to_year, genres, @callback, nil)
+        subscribe_for_callbacks do |callback|
+          @pointer = Spotify.radio_search_create!(session.pointer, from_year, to_year, genres, callback, nil)
+        end
 
-        raise FFI::NullPointerError, "radio search failed" if @pointer.null?
+        raise FFI::NullPointerError, "radio search failed" if pointer.null?
       end
 
       search
@@ -57,10 +58,12 @@ module Hallon
     # @see http://developer.spotify.com/en/libspotify/docs/group__search.html#gacf0b5e902e27d46ef8b1f40e332766df
     def initialize(query, options = {})
       o = Search.defaults.merge(options)
-      @callback = proc { trigger(:load) }
-      @pointer = Spotify.search_create!(session.pointer, query, o[:tracks_offset].to_i, o[:tracks].to_i, o[:albums_offset].to_i, o[:albums].to_i, o[:artists_offset].to_i, o[:artists].to_i, @callback, nil)
 
-      raise FFI::NullPointerError, "search for “#{query}” failed" if @pointer.null?
+      subscribe_for_callbacks do |callback|
+        @pointer  = Spotify.search_create!(session.pointer, query, o[:tracks_offset].to_i, o[:tracks].to_i, o[:albums_offset].to_i, o[:albums].to_i, o[:artists_offset].to_i, o[:artists].to_i, callback, nil)
+      end
+
+      raise FFI::NullPointerError, "search for “#{query}” failed" if pointer.null?
     end
 
     # @return [Boolean] true if the search has been fully loaded.

data/lib/hallon/session.rb

@@ -30,8 +30,8 @@ module Hallon
       undef :instance
     end
 
-    # Session allows you to define your own callbacks.
-    include Observable
+    # We have Session callbacks that you can listen to!
+    extend Observable::Session
 
     # Initializes the Spotify session. If you need to access the
     # instance at a later time, you can use {instance}.
@@ -105,22 +105,23 @@ module Hallon
         raise ArgumentError, "User-agent must be less than 256 bytes long"
       end
 
-      # Set configuration, as well as callbacks
-      config = Spotify::SessionConfig.new
-      config[:api_version]   = Hallon::API_VERSION
-      config.application_key = appkey
-      @options.each { |(key, value)| config.send(:"#{key}=", value) }
-      config[:callbacks]     = Spotify::SessionCallbacks.create(self, @sp_callbacks = {})
-
       # Default cache size is 0 (automatic)
       @cache_size = 0
 
-      instance_eval(&block) if block_given?
+      subscribe_for_callbacks do |callbacks|
+        config = Spotify::SessionConfig.new
+        config[:api_version]   = Hallon::API_VERSION
+        config.application_key = appkey
+        @options.each { |(key, value)| config.send(:"#{key}=", value) }
+        config[:callbacks]     = callbacks
+
+        instance_eval(&block) if block_given?
 
-      # You pass a pointer to the session pointer to libspotify >:)
-      FFI::MemoryPointer.new(:pointer) do |p|
-        Error::maybe_raise Spotify.session_create(config, p)
-        @pointer = p.read_pointer
+        # You pass a pointer to the session pointer to libspotify >:)
+        FFI::MemoryPointer.new(:pointer) do |p|
+          Error::maybe_raise Spotify.session_create(config, p)
+          @pointer = p.read_pointer
+        end
       end
     end
 
@@ -154,7 +155,8 @@ module Hallon
     def process_events_on(*events)
       yield or protecting_handlers do
         channel = SizedQueue.new(1)
-        on(*events) { |*args| channel << args }
+        block   = proc { |*args| channel << args }
+        events.each { |event| on(event, &block) }
         on(:notify_main_thread) { channel << :notify }
 
         loop do
@@ -399,11 +401,6 @@ module Hallon
       status == :offline
     end
 
-    # @return [String] string representation of the Session.
-    def to_s
-      "<#{self.class.name}:0x#{object_id.to_s(16)} status=#{status} @options=#{options.inspect}>"
-    end
-
     private
       # Set starred status of given tracks.
       #
@@ -426,7 +423,7 @@ module Hallon
         # if the user does not have premium, libspotify will still fire logged_in as :ok,
         # but a few moments later it fires connection_error; waiting for both and checking
         # for errors on both hopefully circumvents this!
-        wait_for(:logged_in, :connection_error) do |_, error|
+        wait_for(:logged_in, :connection_error) do |error|
           Error.maybe_raise(error)
           session.logged_in?
         end

data/lib/hallon/toplist.rb

@@ -6,7 +6,7 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__toplist.html
   class Toplist < Base
-    include Observable
+    extend Observable::Toplist
 
     # Create a Toplist browsing object.
     #
@@ -36,8 +36,9 @@ module Hallon
         region = to_country(region)
       end
 
-      @callback = proc { trigger(:load) }
-      @pointer  = Spotify.toplistbrowse_create!(session.pointer, type, region, user, @callback, nil)
+      subscribe_for_callbacks do |callback|
+        @pointer = Spotify.toplistbrowse_create!(session.pointer, type, region, user, callback, nil)
+      end
     end
 
     # @return [Boolean] true if the toplist is loaded.

data/lib/hallon/user.rb

@@ -13,15 +13,15 @@ module Hallon
     #
     # @see http://developer.spotify.com/en/libspotify/docs/group__inbox.html
     class Post < Base
-      include Observable
+      extend Observable::Post
 
       # @param [Spotify::Pointer<inbox>]
       def initialize(username, message, tracks, &block)
-        @callback = proc { trigger(:load) }
+        ary = FFI::MemoryPointer.new(:pointer, tracks.length)
+        ary.write_array_of_pointer tracks.map(&:pointer)
 
-        FFI::MemoryPointer.new(:pointer, tracks.length) do |ary|
-          ary.write_array_of_pointer tracks.map(&:pointer)
-          @pointer = Spotify.inbox_post_tracks!(session.pointer, username, ary, tracks.length, message, @callback, nil)
+        subscribe_for_callbacks do |callback|
+          @pointer = Spotify.inbox_post_tracks!(session.pointer, username, ary, tracks.length, message, callback, nil)
         end
       end
 

data/lib/hallon/version.rb

@@ -3,5 +3,5 @@ module Hallon
   # Current release version of Hallon
   #
   # @see http://semver.org/
-  VERSION = [0, 11, 0].join('.')
+  VERSION = [0, 12, 0].join('.')
 end

data/spec/hallon/album_browse_spec.rb

@@ -5,6 +5,10 @@ describe Hallon::AlbumBrowse do
       Spotify.should_receive(:albumbrowse_create).and_return(null_pointer)
       expect { mock_session { Hallon::AlbumBrowse.new(mock_album) } }.to raise_error(FFI::NullPointerError)
     end
+
+    it "should raise an error given a non-album spotify pointer" do
+      expect { Hallon::AlbumBrowse.new(mock_artist) }.to raise_error(TypeError)
+    end
   end
 
   let(:browse) do

data/spec/hallon/artist_browse_spec.rb

@@ -5,6 +5,10 @@ describe Hallon::ArtistBrowse do
       Spotify.should_receive(:artistbrowse_create).and_return(null_pointer)
       expect { mock_session { Hallon::ArtistBrowse.new(mock_artist) } }.to raise_error(FFI::NullPointerError)
     end
+
+    it "should raise an error given a non-album spotify pointer" do
+      expect { Hallon::ArtistBrowse.new(mock_album) }.to raise_error(TypeError)
+    end
   end
 
   let(:browse) do

data/spec/hallon/base_spec.rb

@@ -2,34 +2,51 @@ describe Hallon::Base do
   let(:klass) do
     Class.new(Hallon::Base) do
       def initialize(pointer)
-        @pointer = pointer
+        @pointer = to_pointer(pointer, :base) { |x| x }
       end
     end
   end
 
+  let(:base_pointer) do
+    Spotify.stub!(:base_add_ref, :base_release)
+    Spotify::Pointer.new(a_pointer, :base, true)
+  end
+
+  describe "#to_pointer" do
+    it "should not accept raw FFI pointers" do
+      expect { klass.new(a_pointer) }.to raise_error(TypeError)
+    end
+
+    it "should raise an error if given an invalid pointer type" do
+      expect { klass.new(mock_album) }.to raise_error(TypeError)
+    end
+  end
+
   describe ".from" do
     it "should return a new object if given pointer is not null" do
-      a_pointer.should_receive(:null?).and_return(false)
-      klass.from(a_pointer).should_not be_nil
+      klass.from(base_pointer).should_not be_nil
     end
 
     it "should return nil if given pointer is null" do
-      a_pointer.should_receive(:null?).and_return(true)
-      klass.from(a_pointer).should be_nil
+      klass.from(null_pointer).should be_nil
+    end
+
+    it "should return nil if given object is nil" do
+      klass.from(nil).should be_nil
     end
   end
 
   describe "#==" do
     it "should compare the pointers if applicable" do
-      one = klass.new(a_pointer)
-      two = klass.new(a_pointer)
+      one = klass.new(base_pointer)
+      two = klass.new(base_pointer)
 
       one.should eq two
     end
 
     it "should fall back to default object comparison" do
-      one = klass.new(a_pointer)
-      two = klass.new(a_pointer)
+      one = klass.new(base_pointer)
+      two = klass.new(base_pointer)
       two.stub(:respond_to?).and_return(false)
 
       one.should_not eq two