hallon 0.9.1 → 0.10.1

data/CHANGELOG

@@ -1,6 +1,22 @@
 Hallon’s Changelog
 ==================
 
+v10.0.0
+------------------
+[ Added ]
+- Add PlaylistContainer::Folder#rename
+- Add PlaylistContainer#insert_folder
+- Add PlaylistContainer#move (do see #57)
+- Add PlaylistContainer#remove
+- Add ability to retrieve PlaylistContainer folders
+- Make PlaylistContainer#add accept a spotify playlist URI
+- Link.new now supports any #to_link’able object
+- Playlist::Track#moved?
+- PlaylistContainer callback support (to be changed, see #56)
+
+[ Fixed ]
+- A lot of random deadlocks (updated spotify gem dependency)
+
 v0.9.1
 ------------------
 [ Added ]

data/README.markdown

@@ -3,17 +3,17 @@
 
 We rubyists have this awesome [spotify gem][] allowing us to use [libspotify][] from within Ruby, but it has a significant drawback: the `libspotify` API is very hard to use. Now, we can’t have that, so what do we do? We make Hallon!
 
-Hallon is Swedish for “Raspberry”, and has been written to satisfy my needs for API simplicity. It provides you with a wrapper around the spotify gem, making the experience of using `libspotify` from Ruby much more enjoyable.
+Hallon is Swedish for “[Raspberry][]”, and has been written to satisfy my needs for API simplicity. Hallon is written on top of [Spotify for Ruby][], but with the goal of making the experience of using `libspotify` from Ruby much more enjoyable.
 
 Hallon would not have been possible if not for these people:
 
 - Per Reimers, cracking synchronization bugs with me in the deep night (4 AM) and correcting me when I didn’t know better
-- [Spotify][], providing a service worth attention (and my money!)
-- [Linus Oleander][], spawning the need for Hallon by having me in the [radiofy.se](http://radiofy.se) project
+- Spotify, providing a service worth attention (and my money!)
+- Linus Oleander, originally inspiring me to write Hallon (for the radiofy.se project)
 
 Also, these people are worthy of mention simply for their contribution:
 
-- [Jesper Särnesjö][], unknowingly providing me a starting point with [Greenstripes][]
+- Jesper Särnesjö, unknowingly providing me a starting point with [Greenstripes][]
 - Emil “@mrevilme” Palm, for his patience in helping me debug Hallon deadlock issues
 
 Code samples can be found under `examples/` directory.
@@ -59,11 +59,10 @@ License
 -------
 Hallon is licensed under a 2-clause (Simplified) BSD license. More information can be found in the `LICENSE.txt` file.
 
-[spotify gem]:     https://rubygems.org/gems/spotify
-[libspotify]:      http://developer.spotify.com/en/libspotify/overview/
-[Greenstripes]:    http://github.com/sarnesjo/greenstripes
-[Jesper Särnesjö]: http://jesper.sarnesjo.org/
-[Linus Oleander]:  https://github.com/oleander
-[Spotify]:         http://spotify.com/
-[What is Hallon?]: http://burgestrand.se/articles/hallon-delicious-ruby-bindings-to-libspotify.html
-[Build Status]:    https://secure.travis-ci.org/Burgestrand/Hallon.png
+[Raspberry]:        http://images.google.com/search?q=raspberry&tbm=isch
+[Spotify for Ruby]: https://github.com/Burgestrand/libspotify-ruby
+[spotify gem]:      https://rubygems.org/gems/spotify
+[libspotify]:       http://developer.spotify.com/en/libspotify/overview/
+[Greenstripes]:     http://github.com/sarnesjo/greenstripes
+[What is Hallon?]:  http://burgestrand.se/articles/hallon-delicious-ruby-bindings-to-libspotify.html
+[Build Status]:     https://secure.travis-ci.org/Burgestrand/Hallon.png

data/Rakefile

@@ -69,6 +69,7 @@ task 'spotify:coverage' do
     'define_singleton_method', # overloaded by us
     'image_remove_load_callback', # cleared when Image is GCd
     'playlist_remove_callbacks', # cleared when Playlist is GCd
+    'playlistcontainer_remove_callbacks', # cleared when Playlist is GCd
   ]
 
   covered -= ignored

data/examples/show_published_playlists_of_user.rb

@@ -43,37 +43,25 @@ session.login!(ENV['HALLON_USERNAME'], ENV['HALLON_PASSWORD'])
 
 puts "Successfully logged in!"
 
-# Hallon does not have support for the below operations, so we resort
-# to using the raw Spotify gem and FFI for now.
 while username = prompt("Enter a Spotify username: ")
   begin
-    username  = nil if username.empty?
+    puts "Fetching container for #{username}..."
+    published = Hallon::User.new(username).published
+    session.wait_for { published.loaded? }
 
-    puts "Fetching container for #{username || "current user"}..."
-    container = Spotify::session_publishedcontainer_for_user_create!(session.pointer, username)
-    if container.null?
-      puts "Failed (unknown reason)."
-      next
-    end
-
-    session.wait_for { Spotify::playlistcontainer_is_loaded(container) }
-
-    num_playlists = Spotify::playlistcontainer_num_playlists(container)
-    puts "Listing #{num_playlists} playlists."
+    puts "Listing #{published.size} playlists."
+    published.contents.each do |playlist|
+      next if playlist.nil? # folder or somesuch
 
-    num_playlists.times do |i|
-      playlist = Spotify::playlistcontainer_playlist!(container, i)
-      playlist = Hallon::Playlist.new(playlist)
       session.wait_for { playlist.loaded? }
 
       puts
       puts playlist.name << ": "
 
-      num_tracks = playlist.tracks.size
       playlist.tracks.each_with_index do |track, i|
         session.wait_for { track.loaded? }
 
-        puts "\t (#{i+1}/#{num_tracks}) #{track.name}"
+        puts "\t (#{i+1}/#{playlist.size}) #{track.name}"
       end
     end
   rescue Interrupt

data/hallon.gemspec

@@ -5,7 +5,7 @@ require 'hallon/version'
 
 Gem::Specification.new do |gem|
   gem.name     = "hallon"
-  gem.summary  = %Q{Delicious Ruby bindings to the official Spotify API}
+  gem.summary  = %Q{Hallon allows you to write Ruby applications utilizing the official Spotify C API.}
   gem.homepage = "http://github.com/Burgestrand/Hallon"
   gem.authors  = ["Kim Burgestrand"]
   gem.email    = 'kim@burgestrand.se'
@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.platform    = Gem::Platform::RUBY
   gem.required_ruby_version = '~> 1.8'
 
-  gem.add_dependency 'spotify', '~> 10.1.0'
+  gem.add_dependency 'spotify', '~> 10.1.1'
   gem.add_development_dependency 'bundler', '~> 1.0'
   gem.add_development_dependency 'rake', '~> 0.8'
   gem.add_development_dependency 'rspec', '~> 2'

data/lib/hallon/ext/spotify.rb

@@ -199,8 +199,9 @@ module Spotify
     end
   end
 
-  # Extensions to SessionCallbacks, making it easier to define callbacks.
-  SessionCallbacks.class_eval do
+  # Makes it easier binding callbacks safely to callback structs.
+  # When including this class you *must* define `proc_for(member)`!
+  module CallbackStruct
     # Assigns the callbacks to call the given target; the callback
     # procs are stored in the `storage` parameter. **Make sure the
     # storage does not get garbage collected as long as these callbacks
@@ -208,27 +209,42 @@ module Spotify
     #
     # @param [Object] target
     # @param [#[]=] storage
-    def initialize(target, storage)
-      members.each do |member|
-        callback = lambda { |ptr, *args| target.trigger(member, *args) }
-        self[member] = storage[member] = callback
+    def create(target, storage)
+      new.tap do |struct|
+        members.each do |member|
+          struct[member] = storage[member] = proc_for(target, member)
+        end
       end
     end
   end
 
-  PlaylistCallbacks.class_eval do
-    # Assigns the callbacks to call the given target; the callback
-    # procs are stored in the `storage` parameter. **Make sure the
-    # storage does not get garbage collected as long as these callbacks
-    # are needed!**
-    #
-    # @param [Object] target
-    # @param [#[]=] storage
-    def initialize(target, storage)
-      members.each do |member|
-        callback = lambda { |ptr, *args| target.trigger(member, *args[0...-1]) }
-        self[member] = storage[member] = callback
+  class << SessionCallbacks
+    include CallbackStruct
+
+    private
+      # @see CallbackStruct
+      def proc_for(target, member)
+        lambda { |pointer, *args| target.trigger(member, *args) }
+      end
+  end
+
+  class << PlaylistCallbacks
+    include CallbackStruct
+
+    private
+      # @see CallbackStruct
+      def proc_for(target, member)
+        lambda { |pointer, *args, userdata| target.trigger(member, *args) }
+      end
+  end
+
+  class << PlaylistContainerCallbacks
+    include CallbackStruct
+
+    private
+      # @see CallbackStruct
+      def proc_for(target, member)
+        lambda { |pointer, *args, userdata| target.trigger(member, *args) }
       end
-    end
   end
 end

data/lib/hallon/link.rb

@@ -28,6 +28,11 @@ module Hallon
         raise "Link.new requires an existing Session instance"
       end
 
+      # we support any #to_link’able object
+      if uri.respond_to?(:to_link)
+        uri = uri.to_link.pointer
+      end
+
       @pointer = to_pointer(uri, :link) do
         Spotify.link_create_from_string!(uri.to_str)
       end

data/lib/hallon/playlist.rb

@@ -63,7 +63,7 @@ module Hallon
       # @param [Boolean] seen true if the track is now seen
       # @return [Playlist::Track] track at the given index
       def seen=(seen)
-        unless Spotify.playlist_track(playlist.pointer, index) == pointer
+        if moved?
           raise IndexError, "track has moved from #{index}"
         end
 
@@ -71,6 +71,13 @@ module Hallon
         Error.maybe_raise(error)
         @seen = Spotify.playlist_track_seen(playlist.pointer, index)
       end
+
+      # @return [Boolean] true if the track has not yet moved.
+      def moved?
+        # using non-GC version deliberately; no need to keep a reference to
+        # this pointer once we’re done here anyway
+        Spotify.playlist_track(playlist.pointer, index) != pointer
+      end
     end
 
     from_link :playlist do |pointer|
@@ -83,8 +90,9 @@ module Hallon
     #
     # @param [String, Link, FFI::Pointer] link
     def initialize(link)
-      callbacks = Spotify::PlaylistCallbacks.new(self, @sp_callbacks = {})
       @pointer = to_pointer(link, :playlist)
+
+      callbacks = Spotify::PlaylistCallbacks.create(self, @sp_callbacks = {})
       Spotify.playlist_add_callbacks(pointer, callbacks, nil)
     end
 

data/lib/hallon/playlist_container.rb

@@ -1,7 +1,74 @@
 # coding: utf-8
 module Hallon
+  # PlaylistContainers are the objects that hold playlists. Each User
+  # in libspotify has a container for its’ starred and published playlists,
+  # and every logged in user has its’ own container.
+  #
+  # @see http://developer.spotify.com/en/libspotify/docs/group__playlist.html
   class PlaylistContainer < Base
+    # Folders are parts of playlist containers in that they surround playlists
+    # with a beginning marker and an ending marker. The playlists between these
+    # markers are considered "inside the playlist".
     class Folder
+      # @return [PlaylistContainer] playlistcontainer this folder was created from.
+      attr_reader :container
+
+      # @return [Integer] index this folder starts at in the container.
+      attr_reader :begin
+
+      # @return [Integer] index this folder ends at in the container.
+      attr_reader :end
+
+      # @return [Integer]
+      attr_reader :id
+
+      # @return [String]
+      attr_reader :name
+
+      # Rename the folder.
+      #
+      # @note libspotify has no actual folder rename; what happens is that
+      #       the folder is removed and then re-created at the same position.
+      # @param [#to_s] new_name
+      # @return [Folder] the new folder
+      def rename(new_name)
+        raise IndexError, "playlist has moved from #{@begin}..#{@end}" if moved?
+
+        insert_at = @begin
+        container.remove(@begin)
+        container.insert_folder(insert_at, new_name)
+        container.move(insert_at + 1, @end)
+      end
+
+      # @param [PlaylistContainer] container
+      # @param [Range] indices
+      def initialize(container, indices)
+        @container = container
+        @begin     = indices.begin
+        @end       = indices.end
+
+        @id   = Spotify.playlistcontainer_playlist_folder_id(container.pointer, @begin)
+        FFI::Buffer.alloc_out(256) do |buffer|
+          error = Spotify.playlistcontainer_playlist_folder_name(container.pointer, @begin, buffer, buffer.size)
+          Error.maybe_raise(error) # should not fail, but just to be safe!
+
+          @name = buffer.get_string(0)
+        end
+      end
+
+      # @param [Folder] other
+      # @return [Boolean] true if the two folders are the same (same indices, same id).
+      def ==(other)
+        !! [:id, :container, :begin, :end].all? do |attr|
+          public_send(attr) == other.public_send(attr)
+        end if other.is_a?(Folder)
+      end
+
+      # @return [Boolean] true if the folder has moved.
+      def moved?
+        Spotify.playlistcontainer_playlist_folder_id(container.pointer, @begin) != id or
+        Spotify.playlistcontainer_playlist_folder_id(container.pointer, @end) != id
+      end
     end
 
     include Observable
@@ -11,6 +78,9 @@ module Hallon
     # @param [Spotify::Pointer] pointer
     def initialize(pointer)
       @pointer = to_pointer(pointer, :playlistcontainer)
+
+      callbacks = Spotify::PlaylistContainerCallbacks.create(self, @sp_callbacs = {})
+      Spotify.playlistcontainer_add_callbacks(pointer, callbacks, nil)
     end
 
     # @return [Boolean] true if the container is loaded.
@@ -32,40 +102,154 @@ module Hallon
     # @return [Enumerator<Playlist, Folder, nil>] an enumerator of folders and playlists.
     def contents
       Enumerator.new(size) do |i|
-        type = Spotify.playlistcontainer_playlist_type(pointer, i)
-
-        case type
+        case playlist_type(i)
         when :playlist
           playlist = Spotify.playlistcontainer_playlist!(pointer, i)
           Playlist.new(playlist)
-        when :start_folder
-        when :end_folder
+        when :start_folder, :end_folder
+          Folder.new(self, folder_range(i))
         else # :unknown
         end
       end
     end
 
-    # @overload add(name)
-    #   Create a new playlist at the end of the container with the given name.
+    # Add the given playlist to the end of the container.
+    #
+    # If the given `name` is a valid spotify playlist URI, Hallon will add
+    # the existing playlist to the container. To always create a new playlist,
+    # set `force_create` to true.
+    #
+    # @example create a new playlist
+    #   container.add "New playlist"
     #
-    #   @param [String] name
-    #   @return [Playlist, nil] the new playlist, or nil if the operation failed
+    # @example create a new playlist even if it’s a valid playlist URI
+    #   container.add "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi", force: true
     #
-    # @overload add(playlist)
-    #   Add the given playlist to the end of the container.
+    # @example add existing playlist
+    #   playlist = container.add "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi"
     #
-    #   @param [Playlist, Link, #to_link] playlist
-    #   @return [Playlist, nil] the added playlist, or nil if the operation failed
-    def add(name_or_playlist)
-      playlist = if name_or_playlist.is_a?(String)
-        Spotify.playlistcontainer_add_new_playlist!(pointer, name_or_playlist)
+    #   playlist = Hallon::Playlist.new("spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi")
+    #   container.add playlist
+    #
+    #   link = Hallon::Link.new("spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi")
+    #   playlist = container.add link
+    #
+    # @param [String, Playlist, Link] playlist
+    # @param [Boolean] force_create force creation of a new playlist
+    # @return [Playlist, nil] the added playlist, or nil if the operation failed
+    def add(name, force_create = false)
+      playlist = if force_create or not Link.valid?(name) and name.is_a?(String)
+        Spotify.playlistcontainer_add_new_playlist!(pointer, name.to_s)
       else
-        link = name_or_playlist
-        link = link.to_link unless link.is_a?(Link)
+        link = Link.new(name)
         Spotify.playlistcontainer_add_playlist!(pointer, link.pointer)
       end
 
       Playlist.new(playlist) unless playlist.null?
     end
+
+    # Create a new folder with the given name at the end of the container.
+    #
+    # @param [String] name
+    # @return [Folder]
+    # @raise [Error] if the operation failed
+    # @see #insert_folder
+    def add_folder(name)
+      insert_folder(size, name)
+    end
+
+    # Create a new folder with the given name at the specified index.
+    #
+    # @param [Integer] index
+    # @param [String] name
+    # @raise [Error] if the operation failed
+    def insert_folder(index, name)
+      error = Spotify.playlistcontainer_add_folder(pointer, index, name.to_s)
+      Error.maybe_raise(error)
+      contents[index]
+    end
+
+    # Remove a playlist or a folder (but not its’ contents).
+    #
+    # @note When removing a folder, both its’ start and end is removed.
+    # @param [Integer] index
+    # @return [PlaylistContainer]
+    # @raise [Error] if the index is out of range
+    def remove(index)
+      remove = proc { |idx| Spotify.playlistcontainer_remove_playlist(pointer, idx) }
+
+      error = case playlist_type(index)
+      when :start_folder, :end_folder
+        indices = folder_range(index)
+
+        Error.maybe_raise(remove[indices.begin])
+        remove[indices.end - 1] # ^ everything moves down one step
+      else
+        remove[index]
+      end
+
+      tap { Error.maybe_raise(error) }
+    end
+
+    # Move a playlist or a folder.
+    #
+    # @note If moving a folder, only that end of the folder is moved. The folder
+    #       size will change!
+    #
+    # @param [Integer] from
+    # @param [Integer] to
+    # @param [Boolean] dry_run don’t really move anything (useful to check if it can be moved)
+    # @return [Playlist, Folder] the entity that was moved
+    # @raise [Error] if the operation failed
+    def move(from, to, dry_run = false)
+      error = Spotify.playlistcontainer_move_playlist(pointer, from, to, !! dry_run)
+
+      if dry_run
+        error, symbol = Error.disambiguate(error)
+        symbol == :ok
+      else
+        Error.maybe_raise(error)
+        contents[from > to ? to : to - 1]
+      end
+    end
+
+    protected
+      # Given an index, find out the starting point and ending point
+      # of the folder at that index.
+      #
+      # @param [Integer] index
+      # @return [Range] begin..end
+      def folder_range(index)
+        id      = folder_id(index)
+        type    = playlist_type(index)
+        same_id = proc { |idx| folder_id(idx) == id }
+
+        case type
+        when :start_folder
+          beginning = index
+          ending    = (index + 1).upto(size - 1).find(&same_id)
+        when :end_folder
+          ending    = index
+          beginning = (index - 1).downto(0).find(&same_id)
+        end
+
+        if beginning and ending and beginning != ending
+          beginning..ending
+        end
+      end
+
+      # @return [Symbol] playlist type
+      def playlist_type(index)
+        Spotify.playlistcontainer_playlist_type(pointer, index)
+      end
+
+      # @return [Integer] folder ID of folder at `index`.
+      def folder_id(index)
+        Spotify.playlistcontainer_playlist_folder_id(pointer, index)
+      end
+
+    # playlistcontainer_remove_playlist
+    # playlistcontainer_move_playlist
+    # playlistcontainer_add_folder (#insert)
   end
 end

data/lib/hallon/session.rb

@@ -110,7 +110,7 @@ module Hallon
       config[:api_version]   = Hallon::API_VERSION
       config.application_key = appkey
       @options.each { |(key, value)| config.send(:"#{key}=", value) }
-      config[:callbacks]     = Spotify::SessionCallbacks.new(self, @sp_callbacks = {})
+      config[:callbacks]     = Spotify::SessionCallbacks.create(self, @sp_callbacks = {})
 
       # Default cache size is 0 (automatic)
       @cache_size = 0

data/lib/hallon/version.rb

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

data/spec/hallon/link_spec.rb

@@ -20,6 +20,15 @@ describe Hallon::Link do
         Hallon::Session.stub(:instance?).and_return(false)
         expect { Hallon::Link.new("spotify:user:burgestrand") }.to raise_error(/session/i)
       end
+
+      it "should accept any object that supplies a #to_link method" do
+        link = Hallon::Link.new("spotify:user:burgestrand")
+
+        to_linkable = double
+        to_linkable.should_receive(:to_link).and_return(link)
+
+        Hallon::Link.new(to_linkable).should eq link
+      end
     end
 
     describe "::valid?" do

data/spec/hallon/playlist_container_spec.rb

@@ -6,11 +6,11 @@ describe Hallon::PlaylistContainer do
 
   it { should be_loaded }
   its(:owner) { should eq Hallon::User.new("burgestrand") }
-  its(:size) { should eq 1 }
+  its(:size) { should eq 3 }
 
   describe "#add" do
-    context "given a string" do
-      it "should create a new Playlist at the end of the playlist" do
+    context "given a string that’s not a valid spotify playlist uri" do
+      it "should create a new playlist at the end of the container" do
         expect do
           playlist = container.add("Bogus")
 
@@ -20,18 +20,45 @@ describe Hallon::PlaylistContainer do
       end
     end
 
-    it "should add the given Playlist to the end of the container" do
-      expect do
-        playlist = container.add Hallon::Playlist.new(mock_playlist)
-        container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
-      end.to change{ container.size }.by(1)
+    context "given a string that’s a valid spotify playlist uri" do
+      it "should add the existing Playlist at the end of the container" do
+        playlist_uri = "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi"
+        playlist = mock_session { Hallon::Playlist.new(playlist_uri) }
+
+        expect do
+          new_playlist = container.add(playlist_uri)
+
+          new_playlist.should eq playlist
+          container.contents[-1].should eq playlist
+        end.to change{ container.size }.by(1)
+      end
+
+      it "should create a new playlist at the end of the container if forced to" do
+        playlist_uri = "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi"
+
+        expect do
+          new_playlist = container.add(playlist_uri, :force_create)
+
+          new_playlist.name.should eq playlist_uri
+          container.contents[-1].should eq new_playlist
+        end.to change{ container.size }.by(1)
+      end
     end
 
-    it "should add the given Playlist Link to the end of the container" do
-      expect do
-        playlist = container.add Hallon::Link.new("spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi")
-        container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
-      end.to change{ container.size }.by(1)
+    context "given an existing playlist" do
+      it "should add it to the container if it’s a playlist" do
+        expect do
+          container.add Hallon::Playlist.new(mock_playlist)
+          container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
+        end.to change{ container.size }.by(1)
+      end
+
+      it "should add it to the container if it’s a link" do
+        expect do
+          container.add Hallon::Link.new("spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi")
+          container.contents[-1].should eq Hallon::Playlist.new(mock_playlist)
+        end.to change{ container.size }.by(1)
+      end
     end
 
     it "should return nil when failing to add the item" do
@@ -41,63 +68,146 @@ describe Hallon::PlaylistContainer do
     end
   end
 
-  describe "#insert" do
-    it "should add the given Playlist to the given index"
-    it "should add the given Folder to the given index"
+  describe "#add_folder" do
+    it "should add a folder at the end of the container with the given name" do
+      size   = container.size
+      folder = container.add_folder "Bonkers"
+
+      folder.name.should eq "Bonkers"
+      folder.begin.should be size
+      folder.end.should be(size + 1)
+
+      container.contents[-1].should eq folder
+    end
+  end
+
+  describe "#insert_folder" do
+    it "should add a folder at the specified index" do
+      folder = container.insert_folder(2, "Mipmip")
+
+      folder.name.should eq "Mipmip"
+      folder.begin.should be 2
+      folder.end.should be 3
+
+      container.contents[2].should eq folder
+      container.contents[3].should eq folder
+    end
   end
 
   describe "#remove" do
-    it "should remove the playlist at the given index"
-    it "should remove the matching :folder_end if removing a folder"
+    it "should remove the playlist at the given index" do
+      expect { container.remove(0) }.to change { container.size }.by(-1)
+    end
+
+    it "should remove the matching :end_folder if removing a :start_folder" do
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+      expect { container.remove(1) }.to change { container.size }.by(-2)
+      container.contents.map(&:class).should eq [Hallon::Playlist]
+    end
+
+    it "should remove the matching :start_folder if removing a :end_folder" do
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+      expect { container.remove(2) }.to change { container.size }.by(-2)
+      container.contents.map(&:class).should eq [Hallon::Playlist]
+    end
+
+    it "should raise an error if the index is out of range" do
+      expect { container.remove(-1) }.to raise_error(Hallon::Error)
+    end
   end
 
   describe "#move" do
-    it "should move the entity at the given index"
+    it "should move the playlist from the old index to the new index" do
+      playlist = container.contents[0]
+
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+      container.move(0, 2).should eq playlist
+      container.contents.map(&:class).should eq [Hallon::PlaylistContainer::Folder, Hallon::Playlist, Hallon::PlaylistContainer::Folder]
+      container.move(1, 0).should eq playlist
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+    end
+
+    it "should not do anything if it’s a dry-run operation" do
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+      container.move(0, 2, :dry_run).should be_true
+      container.contents.map(&:class).should eq [Hallon::Playlist, Hallon::PlaylistContainer::Folder, Hallon::PlaylistContainer::Folder]
+    end
+
+    it "should not raise an error for an invalid operation when dry_run is active" do
+      container.move(0, -1, :dry_run).should be_false
+    end
+
+    it "should raise an error if the operation failed" do
+      expect { container.move(0, -1) }.to raise_error(Hallon::Error)
+    end
   end
 
   describe "#contents" do
-    #
-    # (0) playlist: Hello
-    # (1) start_folder: Hi
-    # (2) playlist: inside Hi
-    # (3) start_folder: Ho
-    # (4) playlist: inside HiHo
-    # (5) end_folder
-    # (6) playlist: inside Hi2
-    # (7) end_folder
-    # (8) playlist: World
-    #
-    # … should become:
-    #
-    # (0) Playlist #1
-    # (1) Folder #1…#7
-    # (2) Playlist #2
-    # (3) Folder #3…#5
-    # (4) Playlist #4
-    # (5) Folder #3…#5
-    # (6) Playlist #6
-    # (7) Folder #1…#7
-    # (8) Playlist #8
-    #
-    it "should be a collection of folders and playlists"
-
     it "should support retrieving playlists" do
       container.contents[0].should eq Hallon::Playlist.new(mock_playlist)
     end
+
+    it "should support retrieving folders from their start" do
+      folder = Hallon::PlaylistContainer::Folder.new(container, 1..2)
+      container.contents[1].should eq folder
+    end
+
+    it "should support retrieving folders from their end" do
+      folder = Hallon::PlaylistContainer::Folder.new(container, 1..2)
+      container.contents[2].should eq folder
+    end
   end
 
-  describe Hallon::PlaylistContainer::Folder, :pending do
+  describe Hallon::PlaylistContainer::Folder do
     subject { container.contents[1] }
-
-    its(:id)   { should be 1337 }
-    its(:name) { should be "Awesome folder" }
+    let(:folder) { subject }
+
+    its(:id)    { should be 1337 }
+    its(:name)  { should eq "Boogie" }
+    its(:begin) { should be 1 }
+    its(:end)   { should be 2 }
+
+    describe "#moved?" do
+      it "should return true if the folder has moved" do
+        folder.should_not be_moved
+        container.move(folder.begin, 0).id.should eq folder.id
+        folder.should be_moved
+        container.move(0, 2).id.should eq folder.id
+        folder.should_not be_moved
+      end
+    end
 
     describe "#contents" do
       it "should be a collection of folders and playlists"
     end
 
     describe "#rename" do
-      it "should rename the playlist container"
+      it "should not touch the original folder data (but it should remove it)" do
+        container.contents.should include(folder)
+
+        folder.rename("Hiphip")
+
+        folder.id.should eq 1337
+        folder.name.should eq "Boogie"
+        folder.begin.should be 1
+        folder.end.should be 2
+
+        container.contents.should_not include(folder)
+      end
+
+      it "should return a new folder with the new data" do
+        new_folder = folder.rename("Hiphip")
+
+        new_folder.id.should_not eq 1337
+        new_folder.name.should eq "Hiphip"
+        new_folder.begin.should be 1
+        new_folder.end.should be 2
+      end
+
+      it "should raise an error if the folder has moved" do
+        container.move(folder.begin, 0)
+        expect { folder.rename "Boogelyboogely" }.to raise_error(IndexError)
+      end
     end
   end
 end

data/spec/hallon/playlist_spec.rb

@@ -56,6 +56,14 @@ describe Hallon::Playlist do
         track.should_not be_seen
       end
     end
+
+    describe "#moved?" do
+      it "should be true if the track has moved" do
+        track.should_not be_moved
+        track.playlist.move(1, 0)
+        track.should be_moved
+      end
+    end
   end
 
   describe "#subscribers" do

data/spec/hallon/user_spec.rb

@@ -82,6 +82,7 @@ describe Hallon::User do
       end
 
       it "should return nil if not logged in" do
+        Spotify.should_receive(:session_publishedcontainer_for_user_create).and_return(null_pointer)
         mock_session { user.published.should be_nil }
       end
     end

data/spec/support/common_objects.rb

@@ -146,7 +146,7 @@ RSpec::Core::ExampleGroup.instance_eval do
   end
 
   let(:mock_container) do
-    num_items = 1
+    num_items = 3
     items_ptr = FFI::MemoryPointer.new(Spotify::Mock::PlaylistTrack, num_items)
     items = num_items.times.map do |i|
       Spotify::Mock::PlaylistContainerItem.new(items_ptr + Spotify::Mock::PlaylistContainerItem.size * i)
@@ -155,6 +155,14 @@ RSpec::Core::ExampleGroup.instance_eval do
     items[0][:playlist] = mock_playlist
     items[0][:type]     = :playlist
 
+    items[1][:folder_name] = FFI::MemoryPointer.from_string("Boogie")
+    items[1][:type]        = :start_folder
+    items[1][:folder_id]   = 1337
+
+    items[2][:folder_name] = FFI::Pointer::NULL
+    items[2][:type]        = :end_folder
+    items[2][:folder_id]   = 1337
+
     Spotify.mock_playlistcontainer(mock_user, true, num_items, items_ptr, nil, nil)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hallon
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-22 00:00:00.000000000 Z
+date: 2011-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spotify
-  requirement: &70199932063240 !ruby/object:Gem::Requirement
+  requirement: &70214553379640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 10.1.0
+        version: 10.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *70199932063240
+  version_requirements: *70214553379640
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70199932060440 !ruby/object:Gem::Requirement
+  requirement: &70214553395220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70199932060440
+  version_requirements: *70214553395220
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70199932058360 !ruby/object:Gem::Requirement
+  requirement: &70214553394740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '0.8'
   type: :development
   prerelease: false
-  version_requirements: *70199932058360
+  version_requirements: *70214553394740
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70199932057240 !ruby/object:Gem::Requirement
+  requirement: &70214553394240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '2'
   type: :development
   prerelease: false
-  version_requirements: *70199932057240
+  version_requirements: *70214553394240
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70199932056420 !ruby/object:Gem::Requirement
+  requirement: &70214553393680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70199932056420
+  version_requirements: *70214553393680
 - !ruby/object:Gem::Dependency
   name: rdiscount
-  requirement: &70199932055320 !ruby/object:Gem::Requirement
+  requirement: &70214553393200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70199932055320
+  version_requirements: *70214553393200
 description: 
 email: kim@burgestrand.se
 executables: []
@@ -205,7 +205,8 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Delicious Ruby bindings to the official Spotify API
+summary: Hallon allows you to write Ruby applications utilizing the official Spotify
+  C API.
 test_files:
 - spec/fixtures/example_uris.rb
 - spec/fixtures/pink_cover.jpg