hallon 0.14.0 → 0.15.0

data/examples/show_published_playlists_of_user.rb

@@ -1,62 +1,34 @@
 # coding: utf-8
-#
-# DISCLAIMER:
-# This file was written without extensive testing, and is merely an
-# example. Before using this yourself, I advice you to look through
-# the code carefully.
-#
 
-$LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
-
-require 'hallon'
-require './spec/support/config'
-
-# Utility
-def prompt(str)
-  print str
-  gets.chomp
-end
-
-session = Hallon::Session.initialize IO.read(ENV['HALLON_APPKEY']) do
-  on(:log_message) do |message|
-    puts "[LOG] #{message}"
-  end
-
-  on(:connection_error) do |error|
-    Hallon::Error.maybe_raise(error)
-  end
-
-  on(:logged_out) do
-    abort "[FAIL] Logged out!"
-  end
-end
-
-session.login!(ENV['HALLON_USERNAME'], ENV['HALLON_PASSWORD'])
-
-puts "Successfully logged in!"
+# Require support code, used by all the examples.
+require_relative 'example_support'
+session = Hallon::Session.instance
 
 while username = prompt("Enter a Spotify username: ")
   begin
-    puts "Fetching container for #{username}..."
-    published = Hallon::User.new(username).published
-    session.wait_for { published.loaded? }
+    puts "Loading #{username}."
+    user = Hallon::User.new(username)
 
-    puts "Listing #{published.size} playlists."
-    published.contents.each do |playlist|
-      next if playlist.nil? # folder or somesuch
+    puts "Fetching published playlists for #{username}..."
+    published = user.published.load
 
-      session.wait_for { playlist.loaded? }
+    puts "Loading #{published.size} playlists."
+    all_playlists = published.contents.find_all do |playlist|
+      playlist.is_a?(Hallon::Playlist) # ignore folders
+    end
 
-      puts
-      puts playlist.name << ": "
+    all_playlists.each(&:load)
 
-      playlist.tracks.each_with_index do |track, i|
-        session.wait_for { track.loaded? }
+    all_playlists.each do |playlist|
+      puts
+      puts "Listing tracks for #{playlist.name} (#{playlist.to_str}):"
 
+      tracks = playlist.tracks.to_a.map(&:load)
+      tracks.each_with_index do |track, i|
         puts "\t (#{i+1}/#{playlist.size}) #{track.name}"
       end
     end
   rescue Interrupt
-    # do nothing, continue with loop
+    puts "Interrupted!"
   end
 end

data/hallon.gemspec

@@ -22,9 +22,10 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9'
 
   gem.add_dependency 'ref', '~> 1.0'
-  gem.add_dependency 'spotify', '~> 10.3.0'
+  gem.add_dependency 'spotify', '~> 11.0.2'
   gem.add_development_dependency 'rake', '~> 0.8'
   gem.add_development_dependency 'rspec', '~> 2'
   gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'bundler'
   gem.add_development_dependency 'rdiscount'
 end

data/lib/hallon.rb

@@ -59,14 +59,15 @@ module Hallon
   # @example
   #   Hallon::URI === "spotify:user:burgestrand" # => true
   URI = /(spotify:(?:
-    (?:artist|album|track|user:[^:]+:playlist):[a-fA-F0-9]+
-    |user:[^:]+
+    (?:artist|album|user:[^:]+:playlist):[a-zA-Z0-9]{22}
+    |track:[a-zA-Z0-9]{22}(?:\#\d{1,2}:\d{1,2})?
+    |user:[^:]+(?::starred)?
     |search:(?:[-\w$\.+!*'(),]+|%[a-fA-F0-9]{2})+
     |image:[a-fA-F0-9]{40}
     ))
   /x
 
-  # Thrown by {Loadable#load} on failure.
+  # Thrown by {Loadable#load} and {Playlist#update} on failure.
   TimeoutError = Class.new(Hallon::Error)
 
   class << self
@@ -83,5 +84,5 @@ module Hallon
     end
   end
 
-  self.load_timeout = 5 # seconds
+  self.load_timeout = 31.4159 # seconds
 end

data/lib/hallon/album.rb

@@ -23,7 +23,7 @@ module Hallon
       Spotify.enum_type(:albumtype).symbols
     end
 
-    extend Linkable
+    include Linkable
     include Loadable
 
     to_link   :from_album

data/lib/hallon/artist.rb

@@ -11,7 +11,7 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__artist.html
   class Artist < Base
-    extend Linkable
+    include Linkable
     include Loadable
 
     from_link :as_artist

data/lib/hallon/base.rb

@@ -1,6 +1,4 @@
 # coding: utf-8
-require 'timeout'
-
 module Hallon
   # All objects in Hallon are mere representations of Spotify objects.
   # Hallon::Base covers basic functionality shared by all of these.
@@ -41,6 +39,7 @@ module Hallon
     end
 
     private
+
       # @macro [attach] to_link
       #   @method to_link
       #   @scope  instance
@@ -72,7 +71,8 @@ module Hallon
       #
       # @param [Spotify::Pointer, String, Link] resource
       # @return [Spotify::Pointer]
-      # @raise [TypeError] when pointer could not be created, or null
+      # @raise [TypeError] when the pointer is of the wrong type
+      # @raise [ArgumentError] when pointer could not be created, or null
       def to_pointer(resource, type, *args)
         if resource.is_a?(FFI::Pointer) and not resource.is_a?(Spotify::Pointer)
           raise TypeError, "Hallon does not support raw FFI::Pointers, wrap it in a Spotify::Pointer"

data/lib/hallon/ext/spotify.rb

@@ -23,6 +23,7 @@ module Spotify
   # @raise [NoMethodError] if `function` is not defined
   # @see Spotify::Pointer
   def self.wrap_function(function, return_type)
+    method(function)
     define_singleton_method("#{function}!") do |*args|
       pointer = public_send(function, *args)
       Spotify::Pointer.new(pointer, return_type, function !~ /create/)
@@ -81,7 +82,6 @@ module Spotify
   wrap_function :link_create_from_user, :link
 
   wrap_function :search_create, :search
-  wrap_function :radio_search_create, :search
   wrap_function :search_track, :track
   wrap_function :search_album, :album
   wrap_function :search_artist, :artist

data/lib/hallon/image.rb

@@ -4,7 +4,7 @@ module Hallon
   #
   # @see http://developer.spotify.com/en/libspotify/docs/group__image.html
   class Image < Base
-    extend Linkable
+    include Linkable
 
     from_link :as_image do |link|
       Spotify.image_create_from_link!(session.pointer, link)

data/lib/hallon/link.rb

@@ -11,6 +11,8 @@ module Hallon
     def self.valid?(spotify_uri)
       if spotify_uri.is_a?(Link)
         return true
+      elsif spotify_uri.to_s["\x00"] # image ids
+        return false
       end
 
       link = Spotify.link_create_from_string!(spotify_uri.to_s)
@@ -54,7 +56,7 @@ module Hallon
     def to_str(length = length)
       FFI::Buffer.alloc_out(length + 1) do |b|
         Spotify.link_as_string(pointer, b, b.size)
-        return b.get_string(0)
+        return b.get_string(0).force_encoding("UTF-8")
       end
     end
 

data/lib/hallon/linkable.rb

@@ -8,123 +8,120 @@ module Hallon
   #
   # @private
   module Linkable
-    # Defines `#from_link`, used in converting a link to a pointer. You
-    # can either pass it a `method_name`, or a `type` and a block.
-    #
-    # @overload from_link(method_name)
-    #   Define `#from_link` simply by giving the name of the method,
-    #   minus the `link_` prefix.
-    #
-    #   @example
-    #     class Album
-    #       extend Linkable
-    #
-    #       from_link :as_album # => Spotify.link_as_album(pointer, *args)
-    #       # ^ is roughly equivalent to:
-    #       def from_link(link, *args)
-    #         unless Spotify::Pointer.typechecks?(link, :link)
-    #           link = Link.new(link).pointer(:album)
-    #         end
-    #
-    #         Spotify.link_as_album!(link)
-    #       end
-    #     end
-    #
-    #   @param [Symbol] method_name
-    #
-    # @overload from_link(type) { |*args| … }
-    #   Define `#from_link` to use the given block to convert an object
-    #   from a link. The link is converted to a pointer and typechecked
-    #   to be of the same type as `type` before given to the block.
-    #
-    #   @example
-    #     class User
-    #       extend Linkable
-    #
-    #       from_link :profile do |pointer|
-    #         Spotify.link_as_user!(pointer)
-    #       end
-    #       # ^ is roughly equivalent to:
-    #       def from_link(link, *args)
-    #         unless Spotify::Pointer.typechecks?(link, :link)
-    #           link = Link.new(link).pointer(:profile)
-    #         end
-    #
-    #         Spotify.link_as_user!(link)
-    #       end
-    #     end
-    #
-    #   @param [#to_s] type link type
-    #   @yield [link, *args] called when conversion is needed from Link pointer
-    #   @yieldparam [Spotify::Pointer] link
-    #   @yieldparam *args any extra arguments given to `#from_link`
-    #
-    # @note Private API. You probably do not need to care about this method.
-    def from_link(as_object, &block)
-      block ||= Spotify.method(:"link_#{as_object}!")
-      type    = as_object.to_s[/^(as_)?([^_]+)/, 2].to_sym
+    module ClassMethods
+      # Defines `#from_link`, used in converting a link to a pointer. You
+      # can either pass it a `method_name`, or a `type` and a block.
+      #
+      # @overload from_link(method_name)
+      #   Define `#from_link` simply by giving the name of the method,
+      #   minus the `link_` prefix.
+      #
+      #   @example
+      #     class Album
+      #       include Linkable
+      #
+      #       from_link :as_album # => Spotify.link_as_album(pointer, *args)
+      #       # ^ is roughly equivalent to:
+      #       def from_link(link, *args)
+      #         unless Spotify::Pointer.typechecks?(link, :link)
+      #           link = Link.new(link).pointer(:album)
+      #         end
+      #
+      #         Spotify.link_as_album!(link)
+      #       end
+      #     end
+      #
+      #   @param [Symbol] method_name
+      #
+      # @overload from_link(type) { |*args| … }
+      #   Define `#from_link` to use the given block to convert an object
+      #   from a link. The link is converted to a pointer and typechecked
+      #   to be of the same type as `type` before given to the block.
+      #
+      #   @example
+      #     class User
+      #       include Linkable
+      #
+      #       from_link :profile do |pointer|
+      #         Spotify.link_as_user!(pointer)
+      #       end
+      #       # ^ is roughly equivalent to:
+      #       def from_link(link, *args)
+      #         unless Spotify::Pointer.typechecks?(link, :link)
+      #           link = Link.new(link).pointer(:profile)
+      #         end
+      #
+      #         Spotify.link_as_user!(link)
+      #       end
+      #     end
+      #
+      #   @param [#to_s] type link type
+      #   @yield [link, *args] called when conversion is needed from Link pointer
+      #   @yieldparam [Spotify::Pointer] link
+      #   @yieldparam *args any extra arguments given to `#from_link`
+      #
+      # @note Private API. You probably do not need to care about this method.
+      def from_link(as_object, &block)
+        block ||= Spotify.method(:"link_#{as_object}!")
+        type    = as_object.to_s[/^(as_)?([^_]+)/, 2].to_sym
+
+        define_method(:from_link) do |link, *args|
+          unless Spotify::Pointer.typechecks?(link, :link)
+            link = Link.new(link).pointer(type)
+          end
 
-      define_method(:from_link) do |link, *args|
-        unless Spotify::Pointer.typechecks?(link, :link)
-          link = Link.new(link).pointer(type)
+          instance_exec(link, *args, &block)
         end
 
-        instance_exec(link, *args, &block)
+        private :from_link
       end
 
-      private :from_link
-    end
-
-    # Defines `#to_link` method, used in converting the object to a {Link}.
-    #
-    # @example
-    #   class Artist
-    #     extend Linkable
-    #
-    #     to_link :from_artist
-    #     # ^ is the same as:
-    #     def to_link(*args)
-    #       link = Spotify.link_create_from_artist!(pointer, *args)
-    #       Link.new(link)
-    #     end
-    #   end
-    #
-    # @param [Symbol] cmethod name of the C method, say `from_artist` in `Spotify.link_create_from_artist`.
-    # @return [Link, nil]
-    def to_link(cmethod)
-      define_method(:to_link) do |*args|
-        link = Spotify.__send__(:"link_create_#{cmethod}!", pointer, *args)
-        Link.from(link)
+      # Defines `#to_link` method, used in converting the object to a {Link}.
+      #
+      # @example
+      #   class Artist
+      #     include Linkable
+      #
+      #     to_link :from_artist
+      #     # ^ is the same as:
+      #     def to_link(*args)
+      #       link = Spotify.link_create_from_artist!(pointer, *args)
+      #       Link.new(link)
+      #     end
+      #   end
+      #
+      # @param [Symbol] cmethod name of the C method, say `from_artist` in `Spotify.link_create_from_artist`.
+      # @return [Link, nil]
+      def to_link(cmethod)
+        define_method(:to_link) do |*args|
+          link = Spotify.__send__(:"link_create_#{cmethod}!", pointer, *args)
+          Link.from(link)
+        end
       end
     end
 
-    private :from_link
-    private :to_link
-
-    def self.extended(other)
-      other.send(:include, InstanceMethods)
+    def self.included(other)
+      other.extend ClassMethods
     end
 
-    module InstanceMethods
-      # Converts the Linkable first to a Link, and then that link to a String.
-      #
-      # @note Returns an empty string if the #to_link call fails.
-      # @return [String]
-      def to_str
-        link = to_link
-        link &&= link.to_str
-        link.to_s
-      end
+    # Converts the Linkable first to a Link, and then that link to a String.
+    #
+    # @note Returns an empty string if the #to_link call fails.
+    # @return [String]
+    def to_str
+      link = to_link
+      link &&= link.to_str
+      link.to_s
+    end
 
-      # Compare the Linkable to other. If other is a Linkable, also
-      # compare their `to_link` if necessary.
-      #
-      # @param [Object] other
-      # @return [Boolean]
-      def ===(other)
-        super or if other.respond_to?(:to_link)
-          to_link == other.to_link
-        end
+    # Compare the Linkable to other. If other is a Linkable, also
+    # compare their `to_link` if necessary.
+    #
+    # @param [Object] other
+    # @return [Boolean]
+    def ===(other)
+      super or if other.respond_to?(:to_link)
+        to_link == other.to_link
       end
     end
   end

data/lib/hallon/loadable.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+require 'timeout'
 
 module Hallon
   module Loadable

data/lib/hallon/observable.rb

@@ -101,12 +101,14 @@ module Hallon
     # Defines a handler for the given event.
     #
     # @param [#to_s] event name of event to handle
-    # @return [Proc] the given block
+    # @return [Proc] the previous handler
     # @yield (*args) event handler block
     def on(event, &block)
       raise ArgumentError, "no block given" unless block
       raise NameError, "no such callback: #{event}" unless has_callback?(event)
-      handlers[event.to_s] = block
+      handlers[event.to_s].tap do
+        handlers[event.to_s] = block
+      end
     end
 
     # @param [#to_s] name