hallon 0.12.0 → 0.13.0

data/lib/hallon/search.rb

@@ -5,6 +5,51 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__search.html
   class Search < Base
+    # Enumerates through all tracks of a search object.
+    class Tracks < Enumerator
+      size :search_num_tracks
+
+      # @return [Track, nil]
+      item :search_track! do |track|
+        Track.from(track)
+      end
+
+      # @return [Integer] total number of tracks from connected search result.
+      def total
+        Spotify.search_total_tracks(pointer)
+      end
+    end
+
+    # Enumerates through all albums of a search object.
+    class Albums < Enumerator
+      size :search_num_albums
+
+      # @return [Album, nil]
+      item :search_album! do |album|
+        Album.from(album)
+      end
+
+      # @return [Integer] total number of tracks from connected search result.
+      def total
+        Spotify.search_total_albums(pointer)
+      end
+    end
+
+    # Enumerates through all albums of a search object.
+    class Artists < Enumerator
+      size :search_num_artists
+
+      # @return [Artist, nil]
+      item :search_artist! do |artist|
+        Artist.from(artist)
+      end
+
+      # @return [Integer] total tracks available from connected search result.
+      def total
+        Spotify.search_total_artists(pointer)
+      end
+    end
+
     extend Observable::Search
 
     # @return [Array<Symbol>] a list of radio genres available for search
@@ -87,46 +132,19 @@ module Hallon
       Spotify.search_did_you_mean(pointer)
     end
 
-    # @return [Enumerator<Track>] list of all tracks in the search result.
+    # @return [Tracks] list of all tracks in the search result.
     def tracks
-      size = Spotify.search_num_tracks(pointer)
-      Enumerator.new(size) do |i|
-        track = Spotify.search_track!(pointer, i)
-        Track.new(track)
-      end
-    end
-
-    # @return [Integer] total tracks available for this search query.
-    def total_tracks
-      Spotify.search_total_tracks(pointer)
+      Tracks.new(self)
     end
 
-    # @return [Enumerator<Album>] list of all albums in the search result.
+    # @return [Albums] list of all albums in the search result.
     def albums
-      size  = Spotify.search_num_albums(pointer)
-      Enumerator.new(size) do |i|
-        album = Spotify.search_album!(pointer, i)
-        Album.new(album)
-      end
-    end
-
-    # @return [Integer] total tracks available for this search query.
-    def total_albums
-      Spotify.search_total_albums(pointer)
+      Albums.new(self)
     end
 
-    # @return [Enumerator<Artist>] list of all artists in the search result.
+    # @return [Artists] list of all artists in the search result.
     def artists
-      size = Spotify.search_num_artists(pointer)
-      Enumerator.new(size) do |i|
-        artist = Spotify.search_artist!(pointer, i)
-        Artist.new(artist)
-      end
-    end
-
-    # @return [Integer] total tracks available for this search query.
-    def total_artists
-      Spotify.search_total_artists(pointer)
+      Artists.new(self)
     end
 
     # @return [Link] link for this search query.

data/lib/hallon/session.rb

@@ -424,7 +424,7 @@ module Hallon
         # 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|
-          Error.maybe_raise(error)
+          Error.maybe_raise(error, :ignore => :timeout)
           session.logged_in?
         end
       end

data/lib/hallon/toplist.rb

@@ -6,6 +6,36 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__toplist.html
   class Toplist < Base
+    # Enumerates through all tracks of a toplist object.
+    class Tracks < Enumerator
+      size :toplistbrowse_num_tracks
+
+      # @return [Track, nil]
+      item :toplistbrowse_track! do |track|
+        Track.from(track)
+      end
+    end
+
+    # Enumerates through all albums of a toplist object.
+    class Albums < Enumerator
+      size :toplistbrowse_num_albums
+
+      # @return [Album, nil]
+      item :toplistbrowse_album! do |album|
+        Album.from(album)
+      end
+    end
+
+    # Enumerates through all albums of a toplist object.
+    class Artists < Enumerator
+      size :toplistbrowse_num_artists
+
+      # @return [Artist, nil]
+      item :toplistbrowse_artist! do |artist|
+        Artist.from(artist)
+      end
+    end
+
     extend Observable::Toplist
 
     # Create a Toplist browsing object.
@@ -52,31 +82,19 @@ module Hallon
       Spotify.toplistbrowse_error(pointer)
     end
 
-    # @return [Enumerator<Artist>] a list of artists.
+    # @return [Artists] a list of artists.
     def artists
-      size = Spotify.toplistbrowse_num_artists(pointer)
-      Enumerator.new(size) do |i|
-        artist = Spotify.toplistbrowse_artist!(pointer, i)
-        Artist.new(artist)
-      end
+      Artists.new(self)
     end
 
-    # @return [Enumerator<Album>] a list of albums.
+    # @return [Albums] a list of albums.
     def albums
-      size = Spotify.toplistbrowse_num_albums(pointer)
-      Enumerator.new(size) do |i|
-        album = Spotify.toplistbrowse_album!(pointer, i)
-        Album.new(album)
-      end
+      Albums.new(self)
     end
 
-    # @return [Enumerator<Track>] a list of tracks.
+    # @return [Tracks] a list of tracks.
     def tracks
-      size = Spotify.toplistbrowse_num_tracks(pointer)
-      Enumerator.new(size) do |i|
-        track = Spotify.toplistbrowse_track!(pointer, i)
-        Track.new(track)
-      end
+      Tracks.new(self)
     end
 
     # @note If the object is not loaded, the result is undefined.

data/lib/hallon/track.rb

@@ -5,6 +5,16 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__track.html
   class Track < Base
+    # Enumerates through all albums of a search object.
+    class Artists < Enumerator
+      size :track_num_artists
+
+      # @return [Artist, nil]
+      item :track_artist! do |artist|
+        Artist.from(artist)
+      end
+    end
+
     extend Linkable
 
     from_link :as_track_and_offset
@@ -143,13 +153,9 @@ module Hallon
     end
 
     # @note Track must be loaded, or you’ll get zero artists.
-    # @return [Hallon::Enumerator<Artist>] all {Artist}s who performed this Track.
+    # @return [Artists] all {Artist}s who performed this Track.
     def artists
-      size = Spotify.track_num_artists(pointer)
-      Enumerator.new(size) do |i|
-        artist = Spotify.track_artist!(pointer, i)
-        Artist.new(artist)
-      end
+      Artists.new(self)
     end
 
     # @note This’ll always return false unless the track is loaded.

data/lib/hallon/version.rb

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

data/spec/hallon/artist_browse_spec.rb

@@ -24,12 +24,11 @@ describe Hallon::ArtistBrowse do
 
   its('portraits.size') { should eq 2 }
   its('portraits.to_a') do
-    mock_session(2) { subject.map{ |img| img.id(true) }.should eq [mock_image_id, mock_image_id] }
+    stub_session { should eq instantiate(Hallon::Image, mock_image_id, mock_image_id) }
   end
 
-  specify 'portraits(false)' do
-    browse.portraits(false)[0].should eq Hallon::Link.new(mock_image_link)
-  end
+  its('portrait_links.size') { should eq 2 }
+  its('portrait_links.to_a') { should eq instantiate(Hallon::Link, mock_image_link, mock_image_link) }
 
   its('tracks.size') { should eq 2 }
   its('tracks.to_a') { should eq [mock_track, mock_track_two].map{ |p| Hallon::Track.new(p) } }

data/spec/hallon/audio_queue_spec.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+require 'timeout'
+
+describe Hallon::AudioQueue do
+  let(:queue) { Hallon::AudioQueue.new(4) }
+  subject { queue }
+
+  it "should conform to the example specification of its’ documentation" do
+    queue.push([1, 2]).should eq 2
+    queue.push([3]).should eq 1
+    queue.push([4, 5, 6]).should eq 1
+    queue.push([5, 6]).should eq 0
+    queue.pop(1).should eq [1]
+    queue.push([5, 6]).should eq 1
+    queue.pop.should eq [2, 3, 4, 5]
+  end
+
+  describe "#pop" do
+    it "should not block if the queue is not empty" do
+      queue.push([1, 2])
+
+      start = Time.now
+      queue.pop.should eq [1, 2]
+      (Time.now - start).should be_within(0.001).of(0)
+    end
+
+    it "should block if the queue is empty" do
+      queue.size.should be_zero
+
+      # I could mock out ConditionVariable and Mutex, but where’s the fun in that?
+      start = Time.now
+      Thread.start { sleep 0.2; queue.push([1]) }
+      queue.pop.should eq [1]
+      (Time.now - start).should be_within(0.08).of(0.2)
+    end
+  end
+
+  describe "#clear" do
+    it "should clear the queue" do
+      queue.push([1, 2])
+      queue.should_not be_empty
+      queue.clear
+      queue.should be_empty
+    end
+  end
+
+  describe "#format" do
+    it "should clear the queue when setting the format" do
+      queue.push([1, 2])
+      queue.should_not be_empty
+      queue.format = :new_format
+      queue.should be_empty
+    end
+
+    it "should allow setting and retrieving the format" do
+      queue.format.should_not be :new_format
+      queue.format = :new_format
+      queue.format.should be :new_format
+    end
+  end
+
+  describe "#synchronize" do
+    it "should be re-entrant" do
+      expect { queue.synchronize { queue.synchronize {} } }.to_not raise_error
+    end
+  end
+
+  describe "#new_cond" do
+    it "should be bound to the queue" do
+      condvar = queue.new_cond
+      inside  = false
+
+      Thread.new(queue, condvar) do |q, c|
+        q.synchronize do
+          inside = true
+          c.signal
+        end
+      end
+
+      Timeout::timeout(1) do
+        queue.synchronize do
+          condvar.wait_until { inside }
+        end
+      end
+
+      inside.should be_true
+    end
+  end
+end

data/spec/hallon/enumerator_spec.rb

@@ -1,103 +1,128 @@
+# coding: utf-8
 describe Hallon::Enumerator do
-  let(:item) do
-    mock.tap { |x| x.stub(:get).and_return(&alphabet) }
-  end
+  def enumerator(items)
+    Spotify.stub(:enumerator_size => items)
+    Spotify.stub(:enumerator_item).and_return { |_, i| alphabet[i] }
+
+    klass = Class.new(Hallon::Enumerator) do
+      size :enumerator_size
+      item :enumerator_item
+    end
 
-  let(:enum) do
-    Hallon::Enumerator.new(5) { |i| item.get(i) }
+    struct = OpenStruct.new(:pointer => nil)
+    klass.new(struct)
   end
 
+  # our subject
+  let(:enum) { enumerator(5) }
+
+  # this is a proc so we can pass it to #and_return
+  # we can still access elements with #[] though, ain’t that nice?
   let(:alphabet) do
     proc { |x| %w[a b c d e][x] }
   end
 
-
   it "should be an enumerable" do
     enum.should respond_to :each
     enum.should be_an Enumerable
   end
 
   describe "#each" do
-    it "should call the containing block" do
-      enum = Hallon::Enumerator.new(4) { |i| item.get(i) }
+    it "should yield items from the collection" do
       enum.each_with_index { |x, i| x.should eq alphabet[i] }
     end
+
+    it "should stop enumerating if the size shrinks below current index during iteration" do
+      iterations = 0
+
+      enum.map do |x|
+        enum.should_receive(:size).and_return(0)
+        iterations += 1
+      end
+
+      iterations.should eq 1
+    end
   end
 
   describe "#size" do
     it "should return the given size" do
-      Hallon::Enumerator.new(4).size.should eq 4
+      enum.size.should eq 5
     end
   end
 
   describe "#[]" do
+    it "should return nil if #[x] is not within the enumerators’ size (no matter if the value exists or not)" do
+      enum.should_receive(:size).and_return(1)
+      enum[1].should be_nil
+    end
+
     it "should support #[x] within range" do
-      item.should_receive(:get).with(1).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(1).and_return(&alphabet)
 
       enum[1].should eq "b"
     end
 
     it "should support negative #[x] within range" do
-      item.should_receive(:get).with(4).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(4).and_return(&alphabet)
 
       enum[-1].should eq "e"
     end
 
     it "should return nil for #[x] outside range" do
-      item.should_not_receive(:get)
+      alphabet.should_not_receive(:get)
 
       enum[6].should be_nil
     end
 
     it "should return nil for #[-x] outside range" do
-      item.should_not_receive(:get)
+      alphabet.should_not_receive(:get)
 
       enum[-6].should be_nil
     end
 
     it "should return a slice of elements for #[x, y]" do
-      item.should_receive(:get).with(1).and_return(&alphabet)
-      item.should_receive(:get).with(2).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(1).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(2).and_return(&alphabet)
 
       enum[1, 2].should eq %w[b c]
     end
 
     it "should return elements for an inclusive range of #[x..y]" do
-      item.should_receive(:get).with(1).and_return(&alphabet)
-      item.should_receive(:get).with(2).and_return(&alphabet)
-      item.should_receive(:get).with(3).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(1).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(2).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(3).and_return(&alphabet)
 
       enum[1..3].should eq %w[b c d]
     end
 
     it "should return return only existing elements for partly inclusive range of #[x..y]" do
-      item.should_receive(:get).with(4).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(4).and_return(&alphabet)
 
       enum[4..7].should eq %w[e]
     end
 
     it "should return nil for a completely outside range of #[x..y]" do
-      item.should_not_receive(:get)
+      alphabet.should_not_receive(:[])
 
       enum[6..10].should eq nil
     end
 
     it "should return the items for #[-x, y]" do
-      item.should_receive(:get).with(2).and_return(&alphabet)
-      item.should_receive(:get).with(3).and_return(&alphabet)
-      item.should_receive(:get).with(4).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(2).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(3).and_return(&alphabet)
+      alphabet.should_receive(:[]).with(4).and_return(&alphabet)
 
       enum[-3, 3].should eq %w[c d e]
     end
 
     it "should slice between items by #[x, y]" do
-      item.should_not_receive(:get)
+      alphabet.should_not_receive(:[])
 
       enum[5, 1].should eq []
     end
 
     it "should slice between items by #[x..y]" do
-      item.should_not_receive(:get)
+      alphabet.should_not_receive(:[])
 
       enum[5..10].should eq []
     end