spotify 12.2.0 → 12.3.0

data/lib/spotify/gc_wrappers.rb

@@ -1,105 +0,0 @@
-# This file contains a tiny (!) DSL that wraps existing Spotify
-# functions into versions that return Spotify::Pointers instead
-# of the usual FFI::Pointers. The Spotify::Pointer automatically
-# manages the underlying pointers reference count, which allows
-# us to piggyback on the Ruby GC mechanism.
-
-module Spotify
-  # Wraps the function `function` so that it always returns
-  # a Spotify::Pointer with correct refcount. Functions that
-  # contain the word `create` are assumed to start out with
-  # a refcount of `+1`.
-  #
-  # @note This method is removed at the bottom of this file.
-  #
-  # @param [#to_s] function
-  # @param [#to_s] return_type
-  # @raise [NoMethodError] if `function` is not defined
-  # @see Spotify::Pointer
-  def self.wrap_function(function, return_type)
-    method(function) # make sure it exists
-    define_singleton_method("#{function}!") do |*args, &block|
-      pointer = public_send(function, *args, &block)
-      Spotify::Pointer.new(pointer, return_type, function !~ /create/)
-    end
-  end
-
-  # @macro [attach] wrap_function
-  #   Same as {Spotify}.`$1`, but wraps result in a {Spotify::Pointer}.
-  #
-  #   @method $1!
-  #   @return [Spotify::Pointer<$2>]
-  #   @see #$1
-  wrap_function :session_user, :user
-  wrap_function :session_playlistcontainer, :playlistcontainer
-  wrap_function :session_inbox_create, :playlist
-  wrap_function :session_starred_create, :playlist
-  wrap_function :session_starred_for_user_create, :playlist
-  wrap_function :session_publishedcontainer_for_user_create, :playlistcontainer
-
-  wrap_function :track_artist, :artist
-  wrap_function :track_album, :album
-  wrap_function :localtrack_create, :track
-  wrap_function :track_get_playable, :track
-
-  wrap_function :album_artist, :artist
-
-  wrap_function :albumbrowse_create, :albumbrowse
-  wrap_function :albumbrowse_album, :album
-  wrap_function :albumbrowse_artist, :artist
-  wrap_function :albumbrowse_track, :track
-
-  wrap_function :artistbrowse_create, :artistbrowse
-  wrap_function :artistbrowse_artist, :artist
-  wrap_function :artistbrowse_track, :track
-  wrap_function :artistbrowse_album, :album
-  wrap_function :artistbrowse_similar_artist, :artist
-  wrap_function :artistbrowse_tophit_track, :track
-
-  wrap_function :image_create, :image
-  wrap_function :image_create_from_link, :image
-
-  wrap_function :link_as_track, :track
-  wrap_function :link_as_track_and_offset, :track
-  wrap_function :link_as_album, :album
-  wrap_function :link_as_artist, :artist
-  wrap_function :link_as_user, :user
-
-  wrap_function :link_create_from_string, :link
-  wrap_function :link_create_from_track, :link
-  wrap_function :link_create_from_album, :link
-  wrap_function :link_create_from_artist, :link
-  wrap_function :link_create_from_search, :link
-  wrap_function :link_create_from_playlist, :link
-  wrap_function :link_create_from_artist_portrait, :link
-  wrap_function :link_create_from_artistbrowse_portrait, :link
-  wrap_function :link_create_from_album_cover, :link
-  wrap_function :link_create_from_image, :link
-  wrap_function :link_create_from_user, :link
-
-  wrap_function :search_create, :search
-  wrap_function :search_track, :track
-  wrap_function :search_album, :album
-  wrap_function :search_artist, :artist
-  wrap_function :search_playlist, :playlist
-
-  wrap_function :playlist_track, :track
-  wrap_function :playlist_track_creator, :user
-  wrap_function :playlist_owner, :user
-  wrap_function :playlist_create, :playlist
-
-  wrap_function :playlistcontainer_playlist, :playlist
-  wrap_function :playlistcontainer_add_new_playlist, :playlist
-  wrap_function :playlistcontainer_add_playlist, :playlist
-  wrap_function :playlistcontainer_owner, :user
-
-  wrap_function :toplistbrowse_create, :toplistbrowse
-  wrap_function :toplistbrowse_artist, :artist
-  wrap_function :toplistbrowse_album, :album
-  wrap_function :toplistbrowse_track, :track
-
-  wrap_function :inbox_post_tracks, :inbox
-
-  # Clean up
-  class << self; undef :wrap_function; end
-end

data/lib/spotify/types/pointer.rb

@@ -1,59 +0,0 @@
-module Spotify
-  # The Pointer is a kind of AutoPointer specially tailored for Spotify
-  # objects, that releases the raw pointer on GC.
-  class Pointer < FFI::AutoPointer
-    # Raised when #releaser_for is given an invalid type.
-    class InvalidTypeError < StandardError
-    end
-
-    class << self
-      # Create a proc that will accept a pointer of a given type and
-      # release it with the correct function if it’s not null.
-      #
-      # @raise [InvalidTypeError] when given an invalid type
-      # @param [Symbol] type
-      # @return [Proc]
-      def releaser_for(type)
-        unless Spotify.respond_to?(:"#{type}_release!")
-          raise InvalidTypeError, "#{type} is not a valid Spotify type"
-        end
-
-        lambda do |pointer|
-          $stdout.puts "Spotify::#{type}_release!(#{pointer})" if $DEBUG
-          Spotify.send(:"#{type}_release!", pointer) unless pointer.null?
-        end
-      end
-
-      # Checks an object by pointer kind and type.
-      #
-      # @param [Object] object
-      # @param [Symbol] type
-      # @return [Boolean] true if object is a spotify pointer and of correct type
-      def typechecks?(object, type)
-        object.is_a?(Spotify::Pointer) && (object.type == type.to_s)
-      end
-    end
-
-    # @return [Symbol] type
-    attr_reader :type
-
-    # Initialize a Spotify pointer, which will automatically decrease
-    # the reference count of it’s pointer when garbage collected.
-    #
-    # @param [FFI::Pointer] pointer
-    # @param [#to_s] type session, link, etc
-    # @param [Boolean] add_ref will increase refcount by one if true
-    def initialize(pointer, type, add_ref)
-      super pointer, self.class.releaser_for(@type = type.to_s)
-
-      unless pointer.null?
-        Spotify.send(:"#{type}_add_ref!", pointer)
-      end if add_ref
-    end
-
-    # @return [String] representation of the spotify pointer
-    def to_s
-      "<#{self.class} address=0x#{address.to_s(16)} type=#{type}>"
-    end
-  end
-end

data/spec/spotify_spec.rb

@@ -1,467 +0,0 @@
-# coding: utf-8
-require 'rubygems' # needed for 1.8, does not matter in 1.9
-
-require 'ostruct'
-require 'set'
-require 'rbgccxml'
-require 'minitest/mock'
-require 'minitest/autorun'
-
-#
-# Hooking FFI for extra introspection
-#
-require 'ffi'
-
-module Spotify
-  extend FFI::Library
-  extend self
-
-  def attach_function(name, func, arguments, returns = nil, options = nil)
-    args = [name, func, arguments, returns, options].compact
-    args.unshift name.to_s if func.is_a?(Array)
-
-    hargs = [:name, :func, :args, :returns].zip args
-    @attached_methods ||= {}
-    @attached_methods[name.to_s] = hash = Hash[hargs]
-
-    super
-  end
-
-  def resolve_type(type)
-    type = find_type(type)
-    type = type.type if type.respond_to?(:type)
-    type
-  end
-
-  attr_reader :attached_methods
-
-  RUBY_PLATFORM = ENV.fetch('RUBY_PLATFORM') do
-    puts "[WARN] Tests running with default ruby platform, #{::RUBY_PLATFORM}, please be"
-    puts "[WARN] specific in which platform to target by setting ENV[RUBY_PLATFORM]"
-    puts "(warnings coming from #{__FILE__}:#{__LINE__})"
-    puts
-    ::RUBY_PLATFORM
-  end
-end
-
-require 'spotify'
-
-module C
-  extend FFI::Library
-  ffi_lib 'C'
-
-  typedef Spotify::UTF8String, :utf8_string
-
-  attach_function :strncpy, [ :pointer, :utf8_string, :size_t ], :utf8_string
-end
-
-# Used for checking Spotify::Pointer things.
-module Spotify
-  def bogus_add_ref!(pointer)
-  end
-
-  def bogus_release!(pointer)
-  end
-
-  # This may be called after our GC test. Randomly.
-  def garbage_release!(pointer)
-  end
-end
-
-#
-# Utility
-#
-
-API_H_PATH = File.expand_path("../api-#{Spotify.platform}.h", __FILE__)
-API_H_SRC  = File.read(API_H_PATH)
-API_H_XML  = RbGCCXML.parse(API_H_PATH)
-
-#
-# General
-#
-describe Spotify do
-  describe "VERSION" do
-    it "should be defined" do
-      defined?(Spotify::VERSION).must_equal "constant"
-    end
-
-    it "should be the same version as in api.h" do
-      spotify_version = API_H_SRC.match(/#define\s+SPOTIFY_API_VERSION\s+(\d+)/)[1]
-      Spotify::API_VERSION.must_equal spotify_version.to_i
-    end
-  end
-
-  describe ".enum_value!" do
-    it "raises an error if given an invalid enum value" do
-      proc { Spotify.enum_value!(:moo, "error value") }.must_raise(ArgumentError)
-    end
-
-    it "gives back the enum value for that enum" do
-      Spotify.enum_value!(:ok, "error value").must_equal 0
-    end
-  end
-
-  describe Spotify::SessionConfig do
-    it "allows setting boolean values with bools" do
-      subject = Spotify::SessionConfig.new
-
-      subject[:compress_playlists].must_equal false
-      subject[:dont_save_metadata_for_playlists].must_equal false
-      subject[:initially_unload_playlists].must_equal false
-
-      subject[:compress_playlists] = true
-      subject[:dont_save_metadata_for_playlists] = true
-      subject[:initially_unload_playlists] = true
-
-      subject[:compress_playlists].must_equal true
-      subject[:dont_save_metadata_for_playlists].must_equal true
-      subject[:initially_unload_playlists].must_equal true
-    end
-
-    it "should be possible to set the callbacks" do
-      subject = Spotify::SessionConfig.new
-      subject[:callbacks] = Spotify::SessionCallbacks.new
-    end
-  end
-
-  describe Spotify::OfflineSyncStatus do
-    it "allows setting boolean values with bools" do
-      subject = Spotify::OfflineSyncStatus.new
-
-      subject[:syncing].must_equal false
-      subject[:syncing] = true
-      subject[:syncing].must_equal true
-    end
-  end
-
-  describe "audio sample types" do
-    # this is so we can just read audio frames easily based on the sample type
-    Spotify.enum_type(:sampletype).symbols.each do |type|
-      describe type do
-        it "should have a corresponding FFI::Pointer#read_array_of_#{type}" do
-          FFI::Pointer.new(1).must_respond_to "read_array_of_#{type}"
-        end
-      end
-    end
-  end
-
-  describe "error wrapped functions" do
-    wrapped_methods = Spotify.attached_methods.find_all { |meth, info| info[:returns] == :error }
-    wrapped_methods.each do |meth, info|
-      it "raises an error if #{meth}! returns non-ok" do
-        Spotify.stub(meth, :bad_application_key) do
-          proc { Spotify.send("#{meth}!") }.must_raise(Spotify::Error, /BAD_APPLICATION_KEY/)
-        end
-      end
-    end
-  end
-
-  describe "GC wrapped functions" do
-    gc_types = Set.new([:session, :track, :user, :playlistcontainer, :playlist, :link, :album, :artist, :search, :image, :albumbrowse, :artistbrowse, :toplistbrowse, :inbox])
-    wrapped_methods = Spotify.attached_methods.find_all { |meth, info| gc_types.member?(info[:returns]) }
-    wrapped_methods.each do |meth, info|
-      it "returns a Spotify::Pointer for #{meth}!" do
-        Spotify.stub(meth, lambda { FFI::Pointer.new(0) }) do
-          Spotify.send("#{meth}!").must_be_instance_of Spotify::Pointer
-        end
-      end
-    end
-
-    it "adds a ref to the pointer if required" do
-      session = FFI::Pointer.new(1)
-      ref_added = false
-
-      Spotify.stub(:session_user, FFI::Pointer.new(1)) do
-        Spotify.stub(:user_add_ref, proc { ref_added = true; :ok }) do
-          Spotify.session_user!(session)
-        end
-      end
-
-      ref_added.must_equal true
-    end
-
-    it "does not add a ref when the result is null" do
-      session = FFI::Pointer.new(1)
-      ref_added = false
-
-      Spotify.stub(:session_user, FFI::Pointer.new(0)) do
-        Spotify.stub(:user_add_ref, proc { ref_added = true }) do
-          Spotify.session_user!(session)
-        end
-      end
-
-      ref_added.must_equal false
-    end
-
-    it "does not add a ref when the result already has one" do
-      session = FFI::Pointer.new(1)
-      ref_added = false
-
-      Spotify.stub(:albumbrowse_create, FFI::Pointer.new(1)) do
-        Spotify.stub(:albumbrowse_add_ref, proc { ref_added = true }) do
-          # to avoid it trying to GC our fake pointer later, and cause a
-          # segfault in our tests
-          Spotify::Pointer.stub(:releaser_for, proc { proc {} }) do
-            Spotify.albumbrowse_create!(session)
-          end
-        end
-      end
-
-      ref_added.must_equal false
-    end
-  end
-
-  describe Spotify::Pointer do
-    describe ".new" do
-      it "adds a reference on the given pointer" do
-        ref_added = false
-
-        Spotify.stub(:bogus_add_ref!, proc { ref_added = true; :ok }) do
-          Spotify::Pointer.new(FFI::Pointer.new(1), :bogus, true)
-        end
-
-        ref_added.must_equal true
-      end
-
-      it "does not add a reference on the given pointer if it is NULL" do
-        ref_added = false
-
-        Spotify.stub(:bogus_add_ref!, proc { ref_added = true; :ok }) do
-          Spotify::Pointer.new(FFI::Pointer::NULL, :bogus, true)
-        end
-
-        ref_added.must_equal false
-      end
-
-      it "raises an error when given an invalid type" do
-        proc { Spotify::Pointer.new(FFI::Pointer.new(1), :really_bogus, true) }.
-          must_raise(Spotify::Pointer::InvalidTypeError, /invalid/)
-      end
-    end
-
-    describe ".typechecks?" do
-      it "typechecks a given spotify pointer" do
-        pointer = Spotify::Pointer.new(FFI::Pointer.new(1), :bogus, true)
-        bogus   = OpenStruct.new(:type => :bogus)
-        Spotify::Pointer.typechecks?(bogus, :bogus).must_equal false
-        Spotify::Pointer.typechecks?(pointer, :link).must_equal false
-        Spotify::Pointer.typechecks?(pointer, :bogus).must_equal true
-      end
-    end
-
-    describe "garbage collection" do
-      let(:my_pointer) { FFI::Pointer.new(1) }
-
-      it "should work" do
-        gc_count = 0
-
-        Spotify.stub(:garbage_release!, proc { gc_count += 1 }) do
-          5.times { Spotify::Pointer.new(my_pointer, :garbage, false) }
-          5.times { GC.start; sleep 0.01 }
-        end
-
-        # GC tests are a bit funky, but as long as we garbage_release at least once, then
-        # we can assume our GC works properly, but up the stakes just for the sake of it
-        gc_count.must_be :>, 3
-      end
-    end
-  end
-
-  describe Spotify::UTF8String do
-    let(:char) do
-      char = "\xC4"
-      char.force_encoding('ISO-8859-1') if char.respond_to?(:force_encoding)
-      char
-    end
-
-    it "should convert any strings to UTF-8 before reading and writing" do
-      dest   = FFI::MemoryPointer.new(:char, 3) # two bytes for the ä, one for the NULL
-      result = C.strncpy(dest, char, 3)
-
-      result.encoding.must_equal Encoding::UTF_8
-      result.must_equal "Ä"
-      result.bytesize.must_equal 2
-    end if "".respond_to?(:force_encoding)
-
-    it "should do nothing if strings does not respond to #encode or #force_encoding" do
-      dest   = FFI::MemoryPointer.new(:char, 3) # two bytes for the ä, one for the NULL
-      result = C.strncpy(dest, char, 3)
-
-      result.must_equal "\xC4"
-      result.bytesize.must_equal 1
-    end unless "".respond_to?(:force_encoding)
-  end
-
-  describe Spotify::ImageID do
-    let(:context) { nil }
-    let(:subject) { Spotify.find_type(:image_id) }
-    let(:null_pointer) { FFI::Pointer::NULL }
-
-    let(:image_id_pointer) do
-      pointer = FFI::MemoryPointer.new(:char, 20)
-      pointer.write_string(image_id)
-      pointer
-    end
-
-    let(:image_id) do
-      # deliberate NULL in middle of string
-      image_id = ":\xD94#\xAD\xD9\x97f\xE0\x00V6\x05\xC6\xE7n\xD2\xB0\xE4P"
-      image_id.force_encoding("BINARY") if image_id.respond_to?(:force_encoding)
-      image_id
-    end
-
-    describe "from_native" do
-      it "should be nil given a null pointer" do
-        subject.from_native(null_pointer, context).must_be_nil
-      end
-
-      it "should be an image id given a non-null pointer" do
-        subject.from_native(image_id_pointer, context).must_equal image_id
-      end
-    end
-
-    describe "to_native" do
-      it "should be a null pointer given nil" do
-        subject.to_native(nil, context).must_be_nil
-      end
-
-      it "should be a 20-byte C string given an actual string" do
-        pointer = subject.to_native(image_id, context)
-        pointer.read_string(20).must_equal image_id_pointer.read_string(20)
-      end
-
-      it "should raise an error given more or less than a 20 byte string" do
-        proc { subject.to_native(image_id + image_id, context) }.must_raise ArgumentError
-        proc { subject.to_native(image_id[0..10], context) }.must_raise ArgumentError
-      end
-    end
-  end
-end
-
-describe "functions" do
-  API_H_XML.functions.each do |func|
-    next unless func["name"] =~ /\Asp_/
-    attached_name = func["name"].sub(/\Asp_/, '')
-
-    def type_of(type, return_type = false)
-      return case type.to_cpp
-        when "const char*"
-          :utf8_string
-        when /\A(::)?(char|int|size_t|bool|sp_scrobbling_state|sp_session\*|byte)\*/
-          return_type ? :pointer : :buffer_out
-        when /::(.+_cb)\*/
-          $1.to_sym
-        else :pointer
-      end if type.is_a?(RbGCCXML::PointerType)
-
-      case type["name"]
-      when "unsigned int"
-        :uint
-      else
-        type["name"].sub(/\Asp_/, '').to_sym
-      end
-    end
-
-    describe func["name"] do
-      it "should be attached" do
-        Spotify.must_respond_to attached_name
-      end
-
-      it "should expect the correct number of arguments" do
-        Spotify.attached_methods[attached_name][:args].count.
-          must_equal func.arguments.count
-      end
-
-      it "should return the correct type" do
-        current = Spotify.attached_methods[attached_name][:returns]
-        actual  = type_of(func.return_type, true)
-
-        Spotify.resolve_type(current).must_equal Spotify.resolve_type(actual)
-      end
-
-      it "should expect the correct types of arguments" do
-        current = Spotify.attached_methods[attached_name][:args]
-        actual  = func.arguments.map { |arg| type_of(arg.cpp_type) }
-
-        current = current.map { |x| Spotify.resolve_type(x) }
-        actual  = actual.map  { |x| Spotify.resolve_type(x) }
-
-        current.must_equal actual
-      end
-    end
-  end
-end
-
-describe "enums" do
-  API_H_XML.enumerations.each do |enum|
-    attached_enum = Spotify.enum_type enum["name"].sub(/\Asp_/, '').to_sym
-    original_enum = enum.values.map { |v| [v["name"].downcase, v["init"]] }
-
-    describe enum["name"] do
-      it "should exist" do
-        attached_enum.wont_be_nil
-      end
-
-      it "should match the definition" do
-        attached_enum_map = attached_enum.symbol_map
-        original_enum.each do |(name, value)|
-          a_name, a_value = attached_enum_map.max_by { |(n, v)| (n.to_s.length if name.match(n.to_s)).to_i }
-          attached_enum_map.delete(a_name)
-          a_value.to_s.must_equal value
-        end
-      end
-    end
-  end
-end
-
-describe "structs" do
-  API_H_XML.structs.each do |struct|
-    next if struct["incomplete"]
-
-    attached_struct = Spotify.constants.find do |const|
-      struct["name"].gsub('_', '').match(/#{const}/i)
-    end
-
-    attached_members = Spotify.const_get(attached_struct).members.map(&:to_s)
-
-    describe struct["name"] do
-      it "should contain the same attributes" do
-        struct.variables.map(&:name).each_with_index do |member, index|
-          attached_members[index].must_equal member
-        end
-      end
-    end
-  end
-
-  describe Spotify::Subscribers do
-    it "should create the subscribers array using count" do
-      # Memory looks like this:
-      #
-      # 00 00 00 00 <- count of subscribers
-      # 00 00 00 00 <- pointer to subscriber 1
-      # …… …… …… ……
-      # 00 00 00 00 <- pointer to subscriber n
-      real_struct = FFI::MemoryPointer.new(:char, 24)
-      real_struct.put_uint(0, 2)
-      subscribers = %w[a bb].map { |x| FFI::MemoryPointer.from_string(x) }
-      real_struct.put_array_of_pointer(8, subscribers)
-
-      struct = Spotify::Subscribers.new(real_struct)
-      struct[:count].must_equal 2
-      struct[:subscribers].size.must_equal 2
-      struct[:subscribers][0].read_string.must_equal "a"
-      struct[:subscribers][1].read_string.must_equal "bb"
-      proc { struct[:subscribers][2] }.must_raise IndexError
-    end
-
-
-    it "should not fail given an empty subscribers struct" do
-      subscribers = FFI::MemoryPointer.new(:uint)
-      subscribers.write_uint(0)
-
-      subject = Spotify::Subscribers.new(subscribers)
-      subject[:count].must_equal 0
-      proc { subject[:subscribers] }.must_raise ArgumentError
-    end
-  end
-end