hallon 0.4.0 → 0.8.0

data/lib/hallon/toplist.rb

@@ -0,0 +1,83 @@
+module Hallon
+  # Toplists are what they sound like. They’re collections of
+  # artists, albums or tracks popular in a certain area either
+  # by country, user or everywhere.
+  #
+  # @see http://developer.spotify.com/en/libspotify/docs/group__toplist.html
+  class Toplist < Base
+    include Observable
+
+    # Create a Toplist browsing object.
+    #
+    # @overload initialize(type, username)
+    # @overload initialize(type, country)
+    # @overload initialize(type)
+    #
+    # @param [Symbol] type one of :artists, :albums or :tracks
+    # @param [String, Symbol, nil] region username, 2-letter country code or nil
+    def initialize(type, region = nil)
+      case region
+      when String
+        user   = region
+        region = :user
+      when NilClass
+        region = :anywhere
+      when Symbol
+        region = to_country(region)
+      end
+
+      @callback = proc { trigger(:load) }
+      pointer = Spotify.toplistbrowse_create(session.pointer, type, region, user, @callback, nil)
+      @pointer = Spotify::Pointer.new(pointer, :toplistbrowse, false)
+    end
+
+    # @return [Boolean] true if the toplist is loaded
+    def loaded?
+      Spotify.toplistbrowse_is_loaded(@pointer)
+    end
+
+    # @return [Symbol] toplist error status
+    def error
+      Spotify.toplistbrowse_error(@pointer)
+    end
+
+    # @return [Enumerator<Artist>]
+    def artists
+      size = Spotify.toplistbrowse_num_artists(@pointer)
+      Enumerator.new(size) do |i|
+        artist = Spotify.toplistbrowse_artist(@pointer, i)
+        Artist.new(artist)
+      end
+    end
+
+    # @return [Enumerator<Album>]
+    def albums
+      size = Spotify.toplistbrowse_num_albums(@pointer)
+      Enumerator.new(size) do |i|
+        album = Spotify.toplistbrowse_album(@pointer, i)
+        Artist.new(album)
+      end
+    end
+
+    # @return [Enumerator<Track>]
+    def tracks
+      size = Spotify.toplistbrowse_num_tracks(@pointer)
+      Enumerator.new(size) do |i|
+        track = Spotify.toplistbrowse_track(@pointer, i)
+        Artist.new(track)
+      end
+    end
+
+    private
+      # Convert a given two-character region to a Spotify
+      # compliant region (encoded in a 16bit integer).
+      #
+      # @param [#to_s]
+      # @return [Integer]
+      def to_country(region)
+        code = region.to_s.upcase
+        high, low = code.bytes.take(2)
+        (high << 8) | low
+      end
+  end
+end

data/lib/hallon/track.rb

@@ -104,14 +104,69 @@ module Hallon
     # @return [Hallon::Album]
     def album
       album = Spotify.track_album(@pointer)
-      Hallon::Album.new(album) unless album.null?
+      Album.new(album) unless album.null?
     end
 
-    # TODO: available?(session)
-    # TODO: local?(session)
-    # TODO: autolinked?(session)
-    # TODO: starred?(session)
-    # TODO: starred = true (session, array of tracks)
-    # TODO: artists (count, by index)
+    # Artist who performed this Track.
+    #
+    # @note There may be more than one artist, see {#artists} for retrieving them all!
+    # @see #artists
+    # @return [Hallon::Artist, nil]
+    def artist
+      artists.first
+    end
+
+    # All {Artist}s who performed this Track.
+    #
+    # @note Track must be loaded, or you’ll get zero artists.
+    # @return [Hallon::Enumerator<Artist>]
+    def artists
+      size = Spotify.track_num_artists(@pointer)
+      Enumerator.new(size) do |i|
+        artist = Spotify.track_artist(@pointer, i)
+        Artist.new(artist) unless artist.null?
+      end
+    end
+
+    # True if the Track is available.
+    #
+    # @note This’ll always return false unless the track is loaded.
+    # @return [Boolean]
+    def available?
+      Spotify.track_is_available(session.pointer, @pointer)
+    end
+
+    # True if the Track is a local track.
+    #
+    # @note This’ll always return false unless the track is loaded.
+    # @return [Boolean]
+    def local?
+      Spotify.track_is_local(session.pointer, @pointer)
+    end
+
+    # True if the Track is autolinked.
+    #
+    # @note This’ll always return false unless the track is loaded.
+    # @return [Boolean]
+    def autolinked?
+      Spotify.track_is_autolinked(session.pointer, @pointer)
+    end
+
+    # True if the track is starred.
+    #
+    # @note This’ll always return false unless the track is loaded.
+    # @return [Boolean]
+    def starred?
+      Spotify.track_is_starred(session.pointer, @pointer)
+    end
+
+    # Set {#starred?} status of current track.
+    #
+    # @note It’ll set the starred status for the current Session.instance.
+    # @param [Boolean] starred
+    # @return [Boolean]
+    def starred=(starred)
+      starred ? session.star(self) : session.unstar(self)
+    end
   end
 end

data/lib/hallon/user.rb

@@ -17,7 +17,7 @@ module Hallon
     #   @param  [String, Hallon::Link, FFI::Pointer] link
     #   @return [FFI::Pointer]
     from_link :profile do |link|
-      Spotify::link_as_user(link)
+      Spotify.link_as_user(link)
     end
 
     # @macro [attach] to_link
@@ -37,7 +37,7 @@ module Hallon
 
     # @return [Boolean] true if the user is loaded
     def loaded?
-      Spotify::user_is_loaded(@pointer)
+      Spotify.user_is_loaded(@pointer)
     end
 
     # Retrieve the name of the current user.
@@ -48,11 +48,11 @@ module Hallon
     def name(type = :canonical)
       case type
       when :display
-        Spotify::user_display_name(@pointer)
+        Spotify.user_display_name(@pointer)
       when :full
-        Spotify::user_full_name(@pointer)
+        Spotify.user_full_name(@pointer)
       when :canonical
-        Spotify::user_canonical_name(@pointer)
+        Spotify.user_canonical_name(@pointer)
       else
         raise ArgumentError, "expected type to be :display, :full or :canonical, but was #{type}"
       end.to_s
@@ -62,7 +62,7 @@ module Hallon
     #
     # @return [String]
     def picture
-      Spotify::user_picture(@pointer).to_s
+      Spotify.user_picture(@pointer).to_s
     end
   end
 end

data/lib/hallon/version.rb

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

data/spec/hallon/album_browse_spec.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+describe Hallon::AlbumBrowse do
+  subject do
+    mock_session do
+      album = Hallon::Album.new(mock_album)
+      Spotify.should_receive(:albumbrowse_create).and_return(mock_albumbrowse)
+      Hallon::AlbumBrowse.new(album)
+    end
+  end
+
+  it { should be_loaded }
+  its(:error)  { should eq :ok }
+  its(:album)  { should eq Hallon::Album.new(mock_album) }
+  its(:artist) { should eq Hallon::Artist.new(mock_artist) }
+  its('copyrights.size') { should eq 2 }
+  its('copyrights.to_a') { should eq %w[Kim Elin] }
+  its('tracks.size') { should eq 2 }
+  its('tracks.to_a') { should eq [mock_track, mock_track_two].map{ |p| Hallon::Track.new(p) } }
+  its(:review) { should eq "This album is AWESOME" }
+end

data/spec/hallon/album_spec.rb

@@ -6,6 +6,13 @@ describe Hallon::Album do
   its(:year) { should be 2004 }
   its(:type) { should be :single }
 
+  its(:browse) do
+    mock_session do
+      Spotify.should_receive(:albumbrowse_create).exactly(2).times.and_return(mock_albumbrowse)
+      should eq Hallon::AlbumBrowse.new(mock_album)
+    end
+  end
+
   it { should be_available }
   it { should be_loaded }
 
@@ -15,12 +22,12 @@ describe Hallon::Album do
       subject.artist.should be_nil
     end
 
-    it "should be an artist if it exists"
+    it "should be an artist if it exists" do
+      subject.artist.should be_a Hallon::Artist
+    end
   end
 
   describe "cover" do
-    before { Hallon::Session.should_receive(:instance).and_return(session) }
-
     it "should be nil if there is no image" do
       Spotify.should_receive(:album_cover).and_return(null_pointer)
       subject.cover.should be_nil
@@ -31,14 +38,12 @@ describe Hallon::Album do
         ptr.write_string(mock_image_id)
 
         Spotify.should_receive(:album_cover).and_return(ptr)
-        subject.cover.id.should eq mock_image_hex
+        mock_session { subject.cover.id.should eq mock_image_hex }
       end
     end
   end
 
   describe ".types" do
-    it "should not be an empty hash" do
-      Hallon::Album.types.should_not be_empty
-    end
+    specify { Hallon::Album.types.should_not be_empty }
   end
 end

data/spec/hallon/artist_browse_spec.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+describe Hallon::ArtistBrowse do
+  subject do
+    mock_session do
+      artist = Hallon::Artist.new(mock_artist)
+      Spotify.should_receive(:artistbrowse_create).and_return(mock_artistbrowse)
+      Hallon::ArtistBrowse.new(artist)
+    end
+  end
+
+  it { should be_loaded }
+  its(:error)  { should eq :ok }
+  its(:artist) { should eq Hallon::Artist.new(mock_artist) }
+
+  its('portraits.size') { should eq 2 }
+  its('portraits.to_a') do
+    Hallon::Session.should_receive(:instance).exactly(2).times.and_return(session)
+
+    subject.map{ |img| img.id(true) }.should eq [mock_image_id, mock_image_id]
+  end
+
+  its('tracks.size') { should eq 2 }
+  its('tracks.to_a') { should eq [mock_track, mock_track_two].map{ |p| Hallon::Track.new(p) } }
+  its('albums.size') { should eq 1 }
+  its('albums.to_a') { should eq [Hallon::Album.new(mock_album)] }
+  its('similar_artists.size') { should eq 2 }
+  its('similar_artists.to_a') { should eq [mock_artist, mock_artist_two].map{ |p| Hallon::Artist.new(p) } }
+  its(:biography) { should eq 'grew up in DA BLOCK' }
+end

data/spec/hallon/artist_spec.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+describe Hallon::Artist do
+  subject { Hallon::Artist.new(mock_artist) }
+
+  it { should be_loaded }
+  its(:name) { should eq "Jem" }
+  its(:browse) do
+    Hallon::Session.should_receive(:instance).exactly(2).times.and_return(session)
+    Spotify.should_receive(:artistbrowse_create).exactly(2).times.and_return(mock_artistbrowse)
+
+    should eq Hallon::ArtistBrowse.new(mock_artist)
+  end
+
+  describe "#portrait" do
+    let(:link) { Hallon::Link.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663") }
+    let(:link_pointer) { FFI::Pointer.new(link.pointer.address) }
+
+    before do
+      Hallon::Link.new(link_pointer).should eq link
+      Spotify.should_receive(:link_create_from_artist_portrait).with(subject.pointer).and_return(link_pointer)
+    end
+
+    specify "as an image" do
+      Hallon::Session.should_receive(:instance).twice.and_return(session)
+      subject.portrait.should eq Hallon::Image.new(link_pointer)
+    end
+
+    specify "as a link" do
+      subject.portrait(false).should eq link
+    end
+  end
+end

data/spec/hallon/enumerator_spec.rb

@@ -0,0 +1,106 @@
+describe Hallon::Enumerator do
+  let(:item) do
+    mock.tap { |x| x.stub(:get).and_return(&alphabet) }
+  end
+
+  let(:enum) do
+    Hallon::Enumerator.new(5) { |i| item.get(i) }
+  end
+
+  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
+      calls = []
+      enum = Hallon::Enumerator.new(4) { |i| item.get(i) }
+      enum.each_with_index { |x, i| x.should eq alphabet[i] }
+    end
+  end
+
+  describe "#size" do
+    it "should return the given size" do
+      Hallon::Enumerator.new(4).size.should eq 4
+    end
+  end
+
+  describe "#[]" do
+    it "should support #[x] within range" do
+      item.should_receive(:get).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)
+
+      enum[-1].should eq "e"
+    end
+
+    it "should return nil for #[x] outside range" do
+      item.should_not_receive(:get)
+
+      enum[6].should be_nil
+    end
+
+    it "should return nil for #[-x] outside range" do
+      item.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)
+
+      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)
+
+      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)
+
+      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)
+
+      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)
+
+      enum[-3, 3].should eq %w[c d e]
+    end
+
+    it "should slice between items by #[x, y]" do
+      item.should_not_receive(:get)
+
+      enum[5, 1].should eq []
+    end
+
+    it "should slice between items by #[x..y]" do
+      item.should_not_receive(:get)
+
+      enum[5..10].should eq []
+    end
+  end
+end