hallon 0.14.0 → 0.15.0

data/lib/hallon/observable/session.rb

@@ -236,5 +236,18 @@ module Hallon::Observable
     def offline_error_callback(pointer, error)
       trigger(pointer, :offline_error, error)
     end
+
+
+    # @example listening to this event
+    #   session.on(:credentials_blob_updated) do |credentials|
+    #     File.open('.spotify-credentials', 'w') { |io| io.write(credentials) }
+    #   end
+    #
+    # @yield [credentials, self]
+    # @yieldparam [String] credentials
+    # @yieldparam [Session] self
+    def credentials_blob_updated_callback(pointer, credentials)
+      trigger(pointer, :credentials_blob_updated, credentials)
+    end
   end
 end

data/lib/hallon/playlist.rb

@@ -93,7 +93,7 @@ module Hallon
       end
     end
 
-    extend Linkable
+    include Linkable
     include Loadable
 
     # CAN HAZ CALLBAKZ
@@ -150,6 +150,26 @@ module Hallon
       Spotify.playlist_set_collaborative(pointer, !!collaborative)
     end
 
+    # Allow the playlist time to update itself and the Spotify backend.
+    # This method will block until libspotify says the playlist no longer
+    # has pending changes.
+    #
+    # @return [Playlist]
+    def upload(timeout = Hallon.load_timeout)
+      unless pending?
+        # libspotify has this bug where pending? returns false directly after
+        # adding tracks to a playlist; processing events once usually toggles
+        # the playlist into pending? mode
+        session.process_events
+      end
+
+      Timeout.timeout(timeout, Hallon::TimeoutError) do
+        session.wait_for { not pending? }
+      end
+
+      self
+    end
+
     # @return [Boolean] true if playlist has pending changes
     def pending?
       Spotify.playlist_has_pending_changes(pointer)

data/lib/hallon/search.rb

@@ -1,4 +1,6 @@
 # coding: utf-8
+require 'cgi'
+
 module Hallon
   # Search allows you to search Spotify for tracks, albums
   # and artists, just like in the client.
@@ -50,66 +52,59 @@ module Hallon
       end
     end
 
-    extend Observable::Search
-    include Loadable
+    include Linkable
 
-    # @return [Array<Symbol>] a list of radio genres available for search
-    def self.genres
-      Spotify.enum_type(:radio_genre).symbols
+    to_link :from_search
+
+    from_link :search do |link|
+      link = Link.new(link).to_uri
+      ::CGI.unescape(link[/\Aspotify:search:(.+)\z/m, 1])
     end
 
+    extend Observable::Search
+    include Loadable
+
     # @return [Hash] default search parameters
     def self.defaults
       @defaults ||= {
         :tracks  => 25,
         :albums  => 25,
         :artists => 25,
+        :playlists => 25,
         :tracks_offset  => 0,
         :albums_offset  => 0,
-        :artists_offset => 0
+        :artists_offset => 0,
+        :playlists_offset => 0
       }
     end
 
-    # @param [Range<Integer>] range (from_year..to_year)
-    # @param [Symbol, …] genres
-    # @return [Search] radio search in given period and genres
-    def self.radio(range, *genres)
-      from_year, to_year = range.begin, range.end
-      genres = genres.reduce(0) do |mask, genre|
-        mask | Spotify.enum_value!(genre, "genre")
-      end
-
-      search = allocate
-      search.instance_eval do
-        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?
-      end
-
-      search
-    end
-
     # Construct a new search with given query.
     #
-    # @param [String] query search query
+    # @param [String, Link] search search query or spotify URI
     # @param [Hash] options additional search options
     # @option options [#to_i] :tracks (25) max number of tracks you want in result
     # @option options [#to_i] :albums (25) max number of albums you want in result
     # @option options [#to_i] :artists (25) max number of artists you want in result
+    # @option options [#to_i] :playlists (25) max number of playlists you want in result
     # @option options [#to_i] :tracks_offset (0) offset of tracks in search result
     # @option options [#to_i] :albums_offset (0) offset of albums in search result
     # @option options [#to_i] :artists_offset (0) offset of artists in search result
+    # @option options [#to_i] :playlists_offset (0) offset of playlists in search result
     # @see http://developer.spotify.com/en/libspotify/docs/group__search.html#gacf0b5e902e27d46ef8b1f40e332766df
-    def initialize(query, options = {})
-      o = Search.defaults.merge(options)
+    def initialize(search, options = {})
+      opts = Search.defaults.merge(options)
+      opts = opts.values_at(:tracks_offset, :tracks, :albums_offset, :albums, :artists_offset, :artists, :playlists_offset, :playlists).map(&:to_i)
+      search = from_link(search) if Link.valid?(search)
 
       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
+        @pointer = if Spotify::Pointer.typechecks?(search, :search)
+          search
+        else
+          Spotify.search_create!(session.pointer, search, *opts, :standard, callback, nil)
+        end
 
-      raise FFI::NullPointerError, "search for “#{query}” failed" if pointer.null?
+        raise ArgumentError, "search with #{search} failed" if @pointer.null?
+      end
     end
 
     # @return [Boolean] true if the search has been fully loaded.
@@ -147,11 +142,5 @@ module Hallon
     def artists
       Artists.new(self)
     end
-
-    # @return [Link] link for this search query.
-    def to_link
-      link = Spotify.link_create_from_search!(pointer)
-      Link.from(link)
-    end
   end
 end

data/lib/hallon/session.rb

@@ -120,7 +120,7 @@ module Hallon
         # 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
+          @pointer = Spotify::Pointer.new(p.read_pointer, :session, false)
         end
       end
     end
@@ -185,7 +185,11 @@ module Hallon
     # @return [Session]
     # @see login!
     def login(username, password, remember_me = false)
-      tap { Spotify.session_login(pointer, username, password, remember_me) }
+      if username.empty? or password.empty?
+        raise ArgumentError, "username and password may not be blank"
+      end
+
+      tap { Spotify.session_login(pointer, username, password, remember_me, nil) }
     end
 
     # Login the remembered user (see {#login}).
@@ -420,10 +424,7 @@ module Hallon
       # @see login!
       # @see relogin!
       def wait_until_logged_in
-        # 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(:connection_error) do |error|
           Error.maybe_raise(error, :ignore => :timeout)
           session.logged_in?
         end

data/lib/hallon/track.rb

@@ -15,7 +15,7 @@ module Hallon
       end
     end
 
-    extend Linkable
+    include Linkable
     include Loadable
 
     from_link :as_track_and_offset

data/lib/hallon/user.rb

@@ -68,7 +68,7 @@ module Hallon
       end
     end
 
-    extend Linkable
+    include Linkable
     include Loadable
 
     from_link :profile do |link|

data/lib/hallon/version.rb

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

data/spec/hallon/album_spec.rb

@@ -49,7 +49,7 @@ describe Hallon::Album do
     end
 
     it "should be a link if it exists" do
-      album.cover_link.should eq Hallon::Link.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450")
+      album.cover_link.should eq Hallon::Link.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e400")
     end
   end
 

data/spec/hallon/hallon_spec.rb

@@ -5,7 +5,7 @@ describe Hallon do
   end
 
   describe "API_VERSION" do
-    specify { Hallon::API_VERSION.should == 10 }
+    specify { Hallon::API_VERSION.should == 11 }
   end
 
   describe "API_BUILD" do
@@ -13,9 +13,8 @@ describe Hallon do
   end
 
   describe "URI" do
-    subject { Hallon::URI }
     example_uris.keys.each do |uri|
-      it { should match uri }
+      specify(uri) { Hallon::URI.match(uri)[0].should eq uri }
     end
   end
 
@@ -25,9 +24,8 @@ describe Hallon do
     end
 
     it "should allow setting and retrieving the value" do
-      Hallon.load_timeout.should eq 5
-      Hallon.load_timeout = 0.2
-      Hallon.load_timeout.should eq 0.2
+      expect { Hallon.load_timeout = 0.2 }.
+        to change { Hallon.load_timeout }
     end
   end
 end

data/spec/hallon/link_spec.rb

@@ -50,6 +50,10 @@ describe Hallon::Link do
     it "should truncate if given a small maximum length" do
       subject.to_str(7).should == "spotify"
     end
+
+    it "should be in UTF-8 encoding" do
+      subject.to_str.encoding.should eq Encoding::UTF_8
+    end
   end
 
   describe "#to_url" do

data/spec/hallon/linkable_spec.rb

@@ -2,7 +2,7 @@ describe Hallon::Linkable do
   let(:klass) do
     klass = Class.new
     klass.instance_eval do
-      extend Hallon::Linkable
+      include Hallon::Linkable
     end
     klass
   end

data/spec/hallon/observable_spec.rb

@@ -117,6 +117,15 @@ describe Hallon::Observable do
       x.should eq 0
     end
 
+    it "should return the previous callback" do
+      previous = proc { puts "hey!" }
+      new_one  = proc { puts "ho!" }
+      initial  = subject.on(:testing, &previous)
+
+      subject.on(:testing, &new_one).should eq previous
+      subject.on(:testing, &previous).should eq new_one
+    end
+
     it "should raise an error trying to bind to a non-existing callback" do
       expect { subject.on("nonexisting") {} }.to raise_error(NameError)
     end

data/spec/hallon/player_spec.rb

@@ -149,7 +149,7 @@ describe Hallon::Player do
 
     context "the output streaming" do
       it "should feed music to the output stream if the format stays the same" do
-        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+        Thread.stub(:start).and_return{ |*args, &block| block[*args] }
 
         player # create the Player
         session.trigger(:music_delivery, queue.format, [1, 2, 3])
@@ -169,7 +169,7 @@ describe Hallon::Player do
       end
 
       it "should set the driver format and return no audio if audio format has changed" do
-        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+        Thread.stub(:start).and_return{ |*args, &block| block[*args] }
 
         player # create the Player
         session.trigger(:start_playback)
@@ -184,7 +184,8 @@ describe Hallon::Player do
       end
 
       it "should set the format on initialization" do
-        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+        Thread.stub(:start).and_return{ |*args, &block| block[*args] }
+
         AudioDriverMock.any_instance.should_receive(:format=)
         Hallon::AudioQueue.any_instance.should_receive(:format=)
         player

data/spec/hallon/playlist_spec.rb

@@ -78,6 +78,17 @@ describe Hallon::Playlist do
     end
   end
 
+  describe "#upload", :stub_session do
+    around(:each) do |example|
+      Timeout.timeout(1) { example.run }
+    end
+
+    it "should raise an error if the playlist takes too long to load" do
+      playlist.stub(:pending? => true)
+      expect { playlist.upload(0.01) }.to raise_error(Hallon::TimeoutError)
+    end
+  end
+
   describe "#subscribers" do
     it "should return an array of names for the subscribers" do
       subject.subscribers.should eq %w[Kim Elin Ylva]

data/spec/hallon/search_spec.rb

@@ -1,30 +1,40 @@
+# coding: utf-8
+require 'cgi'
+
 describe Hallon::Search do
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:search:my+%C3%A5+utf8+%EF%A3%BF+query" }
+    let(:custom_object) { "http://open.spotify.com/search/my+%C3%A5+utf8+%EF%A3%BF+query" }
+    let(:described_class) { stub_session(Hallon::Search) }
+  end
+
   it { should be_a Hallon::Loadable }
 
   subject { search }
   let(:search) do
-    Spotify.registry_add 'spotify:search:my query', mock_search
-    mock_session { Hallon::Search.new("my query") }
+    mock_session { Hallon::Search.new("my å utf8  query") }
   end
 
   describe ".new" do
     it "should have some sane defaults" do
-      Spotify.should_receive(:search_create).with(session.pointer, "my query", 0, 25, 0, 25, 0, 25, anything, anything).and_return(mock_search)
-      mock_session { Hallon::Search.new("my query") }
+      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 0, 25, 0, 25, 0, 25, 0, 25, :standard, anything, anything).and_return(mock_search)
+      mock_session { Hallon::Search.new("my å utf8  query") }
     end
 
     it "should allow you to customize the defaults" do
-      Spotify.should_receive(:search_create).with(session.pointer, "my query", 1, 2, 3, 4, 5, 6, anything, anything).and_return(mock_search)
+      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 1, 2, 3, 4, 5, 6, 7, 8, :standard, anything, anything).and_return(mock_search)
       my_params = {
         :tracks_offset  => 1,
         :tracks         => 2,
         :albums_offset  => 3,
         :albums         => 4,
         :artists_offset => 5,
-        :artists        => 6
+        :artists        => 6,
+        :playlists_offset => 7,
+        :playlists      => 8
       }
 
-      mock_session { Hallon::Search.new("my query", my_params) }
+      mock_session { Hallon::Search.new("my å utf8  query", my_params) }
     end
 
     it "should raise an error if the search failed" do
@@ -33,40 +43,10 @@ describe Hallon::Search do
     end
   end
 
-  describe ".genres" do
-    subject { Hallon::Search.genres }
-
-    it { should include :jazz }
-    it { should be_a Array }
-    it { should_not be_empty }
-  end
-
-  describe ".radio" do
-    subject do
-      Spotify.registry_add 'spotify:radio:00002200:1990-2010', mock_search
-      mock_session { Hallon::Search.radio(1990..2010, :jazz, :punk) }
-    end
-
-    it "should raise an error on invalid genres" do
-      Spotify.should_not_receive(:radio_search_create)
-      expect { Hallon::Search.radio(1990..2010, :bogus, :jazz) }.to raise_error(ArgumentError, /bogus/)
-    end
-
-    it "should raise an error if the search failed" do
-      Spotify.should_receive(:radio_search_create).and_return(null_pointer)
-      expect { mock_session { Hallon::Search.radio(1990..1990) } }.to raise_error(/search failed/)
-    end
-
-    it { should be_loaded }
-    its(:status) { should eq :ok }
-    its('tracks.size') { should eq 2 }
-    # ^ should be enough
-  end
-
   it { should be_a Hallon::Observable }
   it { should be_loaded }
   its(:status) { should eq :ok }
-  its(:query) { should eq "my query" }
+  its(:query) { should eq "my å utf8  query" }
   its(:did_you_mean) { should eq "another thing" }
 
   its('tracks.size')  { should eq 2 }
@@ -81,5 +61,5 @@ describe Hallon::Search do
   its('artists.to_a')  { should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two) }
   its('artists.total') { should eq 81104 }
 
-  its(:to_link) { should eq Hallon::Link.new("spotify:search:#{search.query}") }
+  its(:to_link) { should eq Hallon::Link.new("spotify:search:#{CGI.escape(search.query)}") }
 end