hallon 0.11.0 → 0.12.0

data/lib/hallon/observable/album_browse.rb

@@ -0,0 +1,30 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::AlbumBrowse} objects.
+  module AlbumBrowse
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] load callback
+    def initialize_callbacks
+      callback_for(:load)
+    end
+
+    # This callback is fired when the AlbumBrowse object is fully loaded.
+    #
+    # @example listening to this callback
+    #   browse = AlbumBrowse.new(album)
+    #   browse.on(:load) do
+    #     puts "Album browser has loaded!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [AlbumBrowse] self
+    def load_callback(pointer, userdata)
+      trigger(pointer, :load)
+    end
+  end
+end

data/lib/hallon/observable/artist_browse.rb

@@ -0,0 +1,31 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::ArtistBrowse} objects.
+  module ArtistBrowse
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] load callback
+    def initialize_callbacks
+      callback_for(:load)
+    end
+
+    # This callback is fired when the ArtistBrowse object is fully loaded.
+    #
+    # @example listening to this callback
+    #   browse = ArtistBrowse.new(album)
+    #   browse.on(:load) do
+    #     puts "Artist browser has loaded!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [ArtistBrowse] self
+    def load_callback(pointer, userdata)
+      trigger(pointer, :load)
+    end
+  end
+end
+

data/lib/hallon/observable/image.rb

@@ -0,0 +1,31 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::Image} objects.
+  module Image
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] load callback
+    def initialize_callbacks
+      callback_for(:load)
+    end
+
+    # This callback is fired when the Image object is fully loaded.
+    #
+    # @example listening to this callback
+    #   image = Image.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450")
+    #   image.on(:load) do
+    #     puts "Image has loaded"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Image] self
+    def load_callback(pointer, userdata)
+      trigger(pointer, :load)
+    end
+  end
+end
+

data/lib/hallon/observable/player.rb

@@ -0,0 +1,13 @@
+module Hallon::Observable
+  # We only care about a few of the Session callbacks, actually,
+  # but since this object is not *really* a Spotify object we do
+  # cheat a little bit.
+  module Player
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    include Hallon::Observable::Session
+  end
+end

data/lib/hallon/observable/playlist.rb

@@ -0,0 +1,194 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::Playlist} objects.
+  module Playlist
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Spotify::PlaylistCallbacks]
+    def initialize_callbacks
+      struct = Spotify::PlaylistCallbacks.new
+      struct.members.each do |member|
+        struct[member] = callback_for(member)
+      end
+      struct
+    end
+
+    # @example listening to this event
+    #   playlist.on(:tracks_added) do |tracks, position, playlist|
+    #     puts "#{tracks.map(&:name).join(', ')} added at #{position} to #{playlist.name}"
+    #   end
+    #
+    # @yield [tracks, position, self] tracks_added
+    # @yieldparam [Array<Track>] tracks
+    # @yieldparam [Integer] position
+    # @yieldparam [Playlist] self
+    def tracks_added_callback(pointer, tracks, num_tracks, position, userdata)
+      trigger(pointer, :tracks_added, callback_make_tracks(tracks, num_tracks), position)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:tracks_removed) do |tracks, playlist|
+    #     puts "#{tracks.map(&:name).join(', ') removed from #{playlist.name}"
+    #   end
+    #
+    # @yield [tracks, self] tracks_removed
+    # @yieldparam [Array<Track>] tracks
+    # @yieldparam [Playlist] self
+    def tracks_removed_callback(pointer, tracks, num_tracks, userdata)
+      trigger(pointer, :tracks_removed, callback_make_tracks(tracks, num_tracks))
+    end
+
+    # @example listening to this event
+    #   playlist.on(:tracks_moved) do |tracks, new_position, playlist|
+    #     puts "#{tracks.map(&:name).join(', ')} moved to #{new_position} to #{playlist.name}"
+    #   end
+    #
+    # @yield [tracks, new_position, self] tracks_moved
+    # @yieldparam [Array<Track>] tracks
+    # @yieldparam [Integer] new_position
+    # @yieldparam [Playlist] self
+    def tracks_moved_callback(pointer, tracks, num_tracks, new_position, userdata)
+      trigger(pointer, :tracks_moved, callback_make_tracks(tracks, num_tracks), new_position)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:playlist_renamed) do |playlist|
+    #     puts "#{playlist.name} was now previously named something else \o/"
+    #   end
+    #
+    # @yield [self] playlist_renamed
+    # @yieldparam [Playlist] self
+    def playlist_renamed_callback(pointer, userdata)
+      trigger(pointer, :playlist_renamed)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:playlist_state_changed) do |playlist|
+    #     puts "playlist state changed… to what? from what? D:"
+    #   end
+    #
+    # @yield [self] playlist_state_changed
+    # @yieldparam [Playlist] self
+    def playlist_state_changed_callback(pointer, userdata)
+      trigger(pointer, :playlist_state_changed)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:playlist_update_in_progress) do |is_done, playlist|
+    #     puts(is_done ? "DONE!" : "not done :(")
+    #   end
+    #
+    # @yield [is_done, self] playlist_update_in_progress
+    # @yieldparam [Boolean] is_done
+    # @yieldparam [Playlist] self
+    def playlist_update_in_progress_callback(pointer, done, userdata)
+      trigger(pointer, :playlist_update_in_progress, done)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:playlist_metadata_updated) do |playlist|
+    #     puts "#{playlist.name} metadata updated"
+    #   end
+    #
+    # @yield [self] playlist_metadata_updated
+    # @yieldparam [Playlist] self
+    def playlist_metadata_updated_callback(pointer, userdata)
+      trigger(pointer, :playlist_metadata_updated)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:track_created_changed) do |position, user, created_at, playlist|
+    #     track = playlist.tracks[position]
+    #     puts "#{track.name} created-info changed"
+    #   end
+    #
+    # @yield [position, user, created_at, self] track_created_changed
+    # @yieldparam [Integer] position
+    # @yieldparam [User] user
+    # @yieldparam [Time] created_at
+    # @yieldparam [Playlist] self
+    def track_created_changed_callback(pointer, position, user, created_at, userdata)
+      user = Spotify::Pointer.new(user, :user, true)
+      trigger(pointer, :track_created_changed, position, Hallon::User.new(user), Time.at(created_at))
+    end
+
+    # @example listening to this event
+    #   playlist.on(:track_seen_changed) do |position, seen, playlist|
+    #     track = playlist.tracks[position]
+    #     puts "#{track.name}#seen? is #{seen}"
+    #   end
+    #
+    # @yield [position, is_seen, self] track_seen_changed
+    # @yieldparam [Integer] position
+    # @yieldparam [Boolean] is_seen
+    # @yieldparam [Playlist] self
+    def track_seen_changed_callback(pointer, position, seen, userdata)
+      trigger(pointer, :track_seen_changed, position, seen)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:track_message_changed) do |position, message, playlist|
+    #     track = playlist.tracks[position]
+    #     puts "#{track.name} new message: #{message}"
+    #   end
+    #
+    # @yield [position, message, self] track_message_changed
+    # @yieldparam [Integer] position
+    # @yieldparam [String] message
+    # @yieldparam [Playlist] self
+    def track_message_changed_callback(pointer, position, message, userdata)
+      trigger(pointer, :track_message_changed, position, message)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:description_changed) do |description, playlist|
+    #     puts "#{playlist.name} new description: #{description}"
+    #   end
+    #
+    # @yield [description, self] description_changed
+    # @yieldparam [String] description
+    # @yieldparam [Playlist] self
+    def description_changed_callback(pointer, description, userdata)
+      trigger(pointer, :description_changed, description)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:image_changed) do |image, playlist|
+    #     puts "#{playlist.name} has got a new image: #{image.to_link}"
+    #   end
+    #
+    # @yield [image, self] image_changed
+    # @yieldparam [Image, nil] image or nil
+    # @yieldparam [Playlist] self
+    def image_changed_callback(pointer, image, userdata)
+      image = Hallon::Image.from(image)
+      trigger(pointer, :image_changed, image)
+    end
+
+    # @example listening to this event
+    #   playlist.on(:subscribers_changed) do |playlist|
+    #     puts "#{playlist.name} updated its’ subscribers"
+    #   end
+    #
+    # @yield [self] subscribers_changed
+    # @yieldparam [Playlist] self
+    def subscribers_changed_callback(pointer, userdata)
+      trigger(pointer, :subscribers_changed)
+    end
+
+    protected
+      # @param [FFI::Pointer] tracks
+      # @param [Integer] num_tracks
+      # @param [Array<Track>]
+      def callback_make_tracks(tracks, num_tracks)
+        tracks.read_array_of_pointer(num_tracks).map do |track|
+          ptr = Spotify::Pointer.new(track, :track, true)
+          Hallon::Track.new(ptr)
+        end
+      end
+  end
+end

data/lib/hallon/observable/playlist_container.rb

@@ -0,0 +1,74 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::PlaylistContainer} objects.
+  module PlaylistContainer
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Spotify::PlaylistContainerCallbacks]
+    def initialize_callbacks
+      struct = Spotify::PlaylistContainerCallbacks.new
+      struct.members.each do |member|
+        struct[member] = callback_for(member)
+      end
+      struct
+    end
+
+    # @example listening to this event
+    #   playlist_container.on(:playlist_added) do |playlist, position, container|
+    #     puts playlist.name + " added at #{position}."
+    #   end
+    #
+    # @yield [playlist, position, self] playlist_added
+    # @yieldparam [Playlist] playlist
+    # @yieldparam [Integer] position
+    # @yieldparam [PlaylistContainer] self
+    def playlist_added_callback(pointer, playlist, position, userdata)
+      playlist = Spotify::Pointer.new(playlist, :playlist, true)
+      trigger(pointer, :playlist_added, Hallon::Playlist.new(playlist), position)
+    end
+
+    # @example listening to this event
+    #   playlist_container.on(:playlist_removed) do |playlist, position, container|
+    #     puts playlist.name + " removed from #{position}."
+    #   end
+    #
+    # @yield [playlist, position, self] playlist_removed
+    # @yieldparam [Playlist] playlist
+    # @yieldparam [Integer] position
+    # @yieldparam [PlaylistContainer] self
+    def playlist_removed_callback(pointer, playlist, position, userdata)
+      playlist = Spotify::Pointer.new(playlist, :playlist, true)
+      trigger(pointer, :playlist_removed, Hallon::Playlist.new(playlist), position)
+    end
+
+    # @example listening to this event
+    #   playlist_container.on(:playlist_moved) do |playlist, position, new_position, container|
+    #     puts "moved #{playlist.name} from #{position} to #{new_position}"
+    #   end
+    #
+    # @yield [playlist, position, new_position, self] playlist_moved
+    # @yieldparam [Playlist] playlist
+    # @yieldparam [Integer] position
+    # @yieldparam [Integer] new_position
+    # @yieldparam [PlaylistContainer] self
+    def playlist_moved_callback(pointer, playlist, position, new_position, userdata)
+      playlist = Spotify::Pointer.new(playlist, :playlist, true)
+      trigger(pointer, :playlist_moved, Hallon::Playlist.new(playlist), position, new_position)
+    end
+
+    # @example listening to this event
+    #   playlist_container.on(:container_loaded) do |container|
+    #     puts "#{container.owner.name}s container loaded!"
+    #   end
+    #
+    # @yield [self] container_loaded
+    # @yieldparam [PlaylistContainer] self
+    def container_loaded_callback(pointer, userdata)
+      trigger(pointer, :container_loaded)
+    end
+  end
+end

data/lib/hallon/observable/post.rb

@@ -0,0 +1,30 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::User::Post} objects.
+  module Post
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] complete callback
+    def initialize_callbacks
+      callback_for(:complete)
+    end
+
+    # This callback is fired when the Image object is fully loaded.
+    #
+    # @example listening to this callback
+    #   post = user.post(track)
+    #   post.on(:complete) do
+    #     puts "ze user be havin’ sum posts"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [User::Post] self
+    def complete_callback(pointer, userdata)
+      trigger(pointer, :complete)
+    end
+  end
+end

data/lib/hallon/observable/search.rb

@@ -0,0 +1,29 @@
+module Hallon::Observable
+  # Callbacks related to {Hallon::Search} objects.
+  module Search
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Method] load callback
+    def initialize_callbacks
+      callback_for(:load)
+    end
+
+    # This callback is fired when the Image object is fully loaded.
+    #
+    # @example listening to this callback
+    #   search.on(:load) do |search|
+    #     puts "search for #{search.query} is complete!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Search] self
+    def load_callback(pointer, userdata)
+      trigger(pointer, :load)
+    end
+  end
+end

data/lib/hallon/observable/session.rb

@@ -0,0 +1,236 @@
+# coding: utf-8
+module Hallon::Observable
+  # Callbacks related to the {Hallon::Session} object.
+  module Session
+    # Includes {Hallon::Observable} for you.
+    def self.extended(other)
+      other.send(:include, Hallon::Observable)
+    end
+
+    protected
+
+    # @return [Spotify::SessionCallbacks]
+    def initialize_callbacks
+      struct = Spotify::SessionCallbacks.new
+      struct.members.each do |member|
+        struct[member] = callback_for(member)
+      end
+      struct
+    end
+
+    # @example listening to this event
+    #   session.on(:logged_in) do |error|
+    #     puts "Logged in: " + Hallon::Error.explain(error)
+    #   end
+    #
+    # @yield [error, self] logged_in
+    # @yieldparam [Symbol] error
+    # @yieldparam [Session] self
+    # @see Error
+    def logged_in_callback(pointer, error)
+      trigger(pointer, :logged_in, error)
+    end
+
+    # @example listening to this event
+    #   session.on(:logged_out) do
+    #     puts "AHHH!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def logged_out_callback(pointer)
+      trigger(pointer, :logged_out)
+    end
+
+    # @example listening to this event
+    #   session.on(:metadata_updated) do
+    #     puts "wut wut"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def metadata_updated_callback(pointer)
+      trigger(pointer, :metadata_updated)
+    end
+
+    # @example listening to this event
+    #   session.on(:connection_error) do |error|
+    #     puts "Oh noes: " + Hallon::Error.explain(error)
+    #   end
+    #
+    # @yield [error, self]
+    # @yieldparam [Symbol] error
+    # @yieldparam [Session] self
+    # @see Error
+    def connection_error_callback(pointer, error)
+      trigger(pointer, :connection_error, error)
+    end
+
+    # @example listening to this event
+    #   session.on(:message_to_user) do |message|
+    #     puts "OH HAI: #{message}"
+    #   end
+    #
+    # @yield [message, self]
+    # @yieldparam [String] message
+    # @yieldparam [Session] self
+    def message_to_user_callback(pointer, message)
+      trigger(pointer, :message_to_user, message)
+    end
+
+    # @example listening to this event
+    #   session.on(:notify_main_thread) do
+    #     puts "main thread turn on"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def notify_main_thread_callback(pointer)
+      trigger(pointer, :notify_main_thread)
+    end
+
+    # @example listening to this event
+    #   session.on(:music_delivery) do |format, frames|
+    #     puts ""
+    #   end
+    #
+    # @yield [format, frames, self]
+    # @yieldparam [Hash] format (contains :type, :rate, :channels)
+    # @yieldparam [Enumerator<[Integer...]>] frames (each frame is an array containing format[:channels] integers of format[:type])
+    # @yieldparam [Session] self
+    def music_delivery_callback(pointer, format, frames, num_frames)
+      struct = Spotify::AudioFormat.new(format)
+
+      format = {}
+      format[:rate] = struct[:sample_rate]
+      format[:channels] = struct[:channels]
+      format[:type] = struct[:sample_type]
+
+      # read the frames of the given type
+      frames = frames.public_send("read_array_of_#{format[:type]}", num_frames * format[:channels])
+
+      # pass the frames to the callback, allowing it to do whatever
+      consumed_frames = trigger(pointer, :music_delivery, format, frames.each_slice(format[:channels]))
+
+      # finally return how many frames the callback reportedly consumed
+      consumed_frames.to_i # very important to return something good here!
+    end
+
+    # @example listening to this event
+    #   session.on(:play_token_lost) do
+    #     puts "another user set us up the bomb!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def play_token_lost_callback(pointer)
+      trigger(pointer, :play_token_lost)
+    end
+
+    # @example listening to this event
+    #   session.on(:end_of_track) do
+    #     puts "all your base are belong to us"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def end_of_track_callback(pointer)
+      trigger(pointer, :end_of_track)
+    end
+
+    # @example listening to this event
+    #   session.on(:start_playback) do
+    #     puts "dum dum tiss"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def start_playback_callback(pointer)
+      trigger(pointer, :start_playback)
+    end
+
+    # @example listening to this event
+    #   session.on(:stop_playback) do
+    #     puts "dum dum tiss"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def stop_playback_callback(pointer)
+      trigger(pointer, :stop_playback)
+    end
+
+    # @example listening to this event
+    #   session.on(:get_audio_buffer_stats) do
+    #     puts "que?"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    # @yieldreturn an integer pair, [samples, dropouts]
+    def get_audio_buffer_stats_callback(pointer, stats)
+      stats = Spotify::AudioBufferStats.new(stats)
+      samples, dropouts = trigger(pointer, :get_audio_buffer_stats)
+      stats[:samples]  = samples.to_i
+      stats[:stutter] = dropouts.to_i
+    end
+
+    # @example listening to this event
+    #   session.on(:streaming_error) do |error|
+    #     puts "boo: " + Hallon::Error.explain(error)
+    #   end
+    #
+    # @yield [error, self]
+    # @yieldparam [Symbol] error
+    # @yieldparam [Session] self
+    def streaming_error_callback(pointer, error)
+      trigger(pointer, :streaming_error, error)
+    end
+
+    # @example listening to this event
+    #   session.on(:userinfo_updated) do
+    #     puts "who am I?!"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def userinfo_updated_callback(pointer)
+      trigger(pointer, :userinfo_updated)
+    end
+
+    # @example listening to this event
+    #   session.on(:log_message) do |message|
+    #     puts "for great justice: #{message}"
+    #   end
+    #
+    # @yield [message, self]
+    # @yieldparam [String] message
+    # @yieldparam [Session] self
+    def log_message_callback(pointer, message)
+      trigger(pointer, :log_message, message)
+    end
+
+    # @example listening to this event
+    #   session.on(:offline_status_updated) do |session|
+    #     puts "All systems: #{session.status}"
+    #   end
+    #
+    # @yield [self]
+    # @yieldparam [Session] self
+    def offline_status_updated_callback(pointer)
+      trigger(pointer, :offline_status_updated)
+    end
+
+    # @example listening to this event
+    #   session.on(:offline_error) do |error|
+    #     puts "FAIL: " + Hallon::Error.explain(error)
+    #   end
+    #
+    # @yield [error, self]
+    # @yieldparam [Symbol] error
+    # @yieldparam [Session] self
+    def offline_error_callback(pointer, error)
+      trigger(pointer, :offline_error, error)
+    end
+  end
+end