spotify 12.3.0 → 12.4.0

data/lib/spotify/managed_pointer.rb

@@ -23,6 +23,10 @@ module Spotify
       # @param [FFI::Pointer] pointer
       def release(pointer)
         unless pointer.null?
+          # this is to circumvent the type protection
+          pointer = base_class.new(pointer)
+          pointer.autorelease = false
+
           $stderr.puts "Spotify.#{type}_release(#{pointer.inspect})" if $DEBUG
           Spotify.public_send("#{type}_release", pointer)
         end
@@ -32,7 +36,7 @@ module Spotify
       #
       # This method derives the retain method from the class name.
       #
-      # @param [FFI::Pointer] pointer
+      # @param [self] pointer must be an instance of {#base_class}
       def retain(pointer)
         unless pointer.null?
           $stderr.puts "Spotify.#{type}_add_ref(#{pointer.inspect})" if $DEBUG
@@ -40,44 +44,70 @@ module Spotify
         end
       end
 
+      # Makes all ManagedPointers typesafe in the sense that they will raise
+      # an argument error on any value that is not of the same kind.
+      def to_native(value, ctx)
+        if value.nil? or value.null?
+          raise TypeError, "#{name} pointers cannot be null, was #{value.inspect}"
+        elsif value.kind_of?(base_class)
+          super
+        else
+          raise TypeError, "expected a kind of #{name}, was #{value.class}"
+        end
+      end
+
+      # Retaining class is needed for the functions that return a pointer that
+      # does not have its reference count increased. This class is a subclass
+      # of the ManagedPointer, and should behave the same in all circumstances
+      # except for during initialization.
+      #
+      # This dynamic method is needed to DRY the pointers up. We have about ten
+      # subclasses of ManagedPointer; all of them need a subclass that retains
+      # its pointer on initialization. We could create one manually for each
+      # Album, Artist, Track, and so on, but that would be annoying.
+      #
       # @return [self] subclass that retains its pointer on initialization.
       def retaining_class
-        @klass ||= Class.new(self) do
-          def initialize(*args, &block)
-            superclass = self.class.superclass
-            superclass.instance_method(:initialize).bind(self).call(*args, &block)
-            superclass.retain(self)
-          end
-
-          class << self
-            alias_method :==, :<=
+        if defined?(self::Retaining)
+          self::Retaining
+        else
+          subclass = Class.new(self) do
+            class << self
+              def type
+                superclass.type
+              end
 
-            # @return [String] delegates to the superclass.
-            def name
-              superclass.name
-            end
+              protected
 
-            # @return [String] delegates to the superclass.
-            def to_s
-              superclass.to_s
+              def base_class
+                superclass
+              end
             end
 
-            # @return [String] string representation of object
-            def inspect
-              "#{superclass}<retaining>"
+            def initialize(*)
+              super
+              self.class.retain(self)
             end
           end
+
+          const_set("Retaining", subclass)
         end
       end
 
-      alias_method :==, :>=
-
       protected
 
-      # @return [#to_s] the spotify type of this pointer.
+      # Retrieves the normalized and downcased name of self, so for
+      # Spotify::Album we’ll receive just “album”.
       def type
         name.split('::')[-1].downcase
       end
+
+      # Retrieves the base class for this pointer. This is overridden
+      # by the {.retaining_class}. It is used for type-checking inside
+      # {.to_native}.
+      def base_class
+        self
+      end
     end
 
     # @return [String] string representation of self.

data/lib/spotify/monkey_patches/ffi_pointer.rb

@@ -0,0 +1,18 @@
+require "ffi"
+
+module FFI
+  class AbstractMemory
+    unless method_defined?(:read_size_t)
+      type = FFI.find_type(:size_t)
+      type, _ = FFI::TypeDefs.find do |(name, t)|
+        method_defined? "read_#{name}" if t == type
+      end
+
+      if type.nil?
+        raise "Missing method to read a size_t from #{klass}"
+      end
+
+      alias_method(:read_size_t, "read_#{type}")
+    end
+  end
+end

data/lib/spotify/structs.rb

@@ -33,6 +33,20 @@ module Spotify
         self[key] = value
       end
     end
+
+    # Convert the struct to a hash.
+    #
+    # @return [Hash]
+    def to_h
+      Hash[members.zip(values)]
+    end
+
+    # String representation of the struct. Looks like a Hash.
+    #
+    # @return [String]
+    def to_s
+      "<#{self.class.name} #{to_h}>"
+    end
   end
 end
 

data/lib/spotify/structs/session_callbacks.rb

@@ -29,7 +29,7 @@ module Spotify
            :connection_error => callback([ Session, :error ], :void),
            :message_to_user => callback([ Session, UTF8String ], :void),
            :notify_main_thread => callback([ Session ], :void),
-           :music_delivery => callback([ Session, AudioFormat, :frames, :int ], :int),
+           :music_delivery => callback([ Session, AudioFormat.by_ref, :frames, :int ], :int),
            :play_token_lost => callback([ Session ], :void),
            :log_message => callback([ Session, UTF8String ], :void),
            :end_of_track => callback([ Session ], :void),
@@ -37,7 +37,7 @@ module Spotify
            :userinfo_updated => callback([ Session ], :void),
            :start_playback => callback([ Session ], :void),
            :stop_playback => callback([ Session ], :void),
-           :get_audio_buffer_stats => callback([ Session, AudioBufferStats ], :void),
+           :get_audio_buffer_stats => callback([ Session, AudioBufferStats.by_ref ], :void),
            :offline_status_updated => callback([ Session ], :void),
            :offline_error => callback([ Session, :error ], :void),
            :credentials_blob_updated => callback([ Session, :string ], :void),

data/lib/spotify/structs/session_config.rb

@@ -51,7 +51,7 @@ module Spotify
       when :application_key
         if value.is_a?(String)
           pointer = FFI::MemoryPointer.new(:char, value.bytesize)
-          pointer.write_bytes(value)
+          pointer.write_string(value)
           super(key, pointer)
           self[:application_key_size] = pointer.size
         else

data/lib/spotify/types/image_id.rb

@@ -8,36 +8,43 @@ module Spotify
     extend FFI::DataConverter
     native_type FFI::Type::POINTER
 
-    # Given a string, convert it to an image ID pointer.
-    #
-    # @param [String] value image id as a string
-    # @param ctx
-    # @return [FFI::Pointer] pointer to the image ID
-    def self.to_native(value, ctx)
-      pointer = if value
-        if value.bytesize != 20
-          raise ArgumentError, "image id bytesize must be 20, was #{value.bytesize}"
-        end
-
-        pointer = FFI::MemoryPointer.new(:char, 20)
-        pointer.write_string(value.to_s)
+    class << self
+      # @return [Integer] bytesize of image ID pointers.
+      def size
+        20
       end
 
-      super(pointer, ctx)
-    end
+      # Given a string, convert it to an image ID pointer.
+      #
+      # @param [#to_str, nil] value image id as a string
+      # @param ctx
+      # @return [FFI::Pointer] pointer to the image ID
+      def to_native(value, ctx)
+        value && begin
+          value = value.to_str
 
-    # Given a pointer, read a 20-byte image ID from it.
-    #
-    # @param [FFI::Pointer] value
-    # @param ctx
-    # @return [String, nil] the image ID as a string, or nil
-    def self.from_native(value, ctx)
-      value.read_string(20) unless value.null?
-    end
+          if value.bytesize != size
+            raise ArgumentError, "image id bytesize must be #{size}, was #{value.bytesize}"
+          end
+
+          pointer = FFI::MemoryPointer.new(:char, size)
+          pointer.write_string(value)
+        end
+      end
 
-    # @see NulString.reference_required?
-    def self.reference_required?
-      true
+      # Given a pointer, read a {.size}-byte image ID from it.
+      #
+      # @param [FFI::Pointer] value
+      # @param ctx
+      # @return [String, nil] the image ID as a string, or nil
+      def from_native(value, ctx)
+        value.read_string(size) unless value.null?
+      end
+
+      # @see NulString.reference_required?
+      def reference_required?
+        true
+      end
     end
   end
 end

data/lib/spotify/types/nul_string.rb

@@ -8,44 +8,33 @@ module Spotify
     extend FFI::DataConverter
     native_type FFI::Type::POINTER
 
-    # Given either a String or nil, make an actual FFI::Pointer
-    # of that value.
-    #
-    # @param [nil, #to_str] value
-    # @param [Object] ctx
-    # @return [FFI::Pointer]
-    def self.to_native(value, ctx)
-      return FFI::Pointer::NULL if value.nil?
-
-      unless value.respond_to?(:to_str)
-        raise TypeError, "#{value.inspect} cannot be converted to string"
+    class << self
+      # Given either a String or nil, make an actual FFI::Pointer
+      # of that value.
+      #
+      # @param [#to_str, nil] value
+      # @param ctx
+      # @return [FFI::Pointer]
+      def to_native(value, ctx)
+        value && FFI::MemoryPointer.from_string(value.to_str)
       end
 
-      # This is alright since MRI and JRuby both
-      # keep a strong reference to this pointer
-      # inside the struct where it’s been assigned.
-      FFI::MemoryPointer.from_string(value.to_str)
-    end
-
-    # Given a pointer, read out it’s string.
-    #
-    # @param [FFI::Pointer] value
-    # @param [Object] ctx
-    # @return [String, nil]
-    def self.from_native(value, ctx)
-      if value.null?
-        nil
-      else
-        value.read_string
+      # Given a pointer, read out it’s string.
+      #
+      # @param [FFI::Pointer] value
+      # @param ctx
+      # @return [String, nil]
+      def from_native(value, ctx)
+        value.read_string unless value.null?
       end
-    end
 
-    # Used by FFI::StructLayoutField to know if this field
-    # requires the reference to be maintained by FFI. If we
-    # return false here, the MemoryPointer from to_native
-    # will be garbage collected before the struct.
-    def self.reference_required?
-      true
+      # Used by FFI::StructLayoutField to know if this field
+      # requires the reference to be maintained by FFI. If we
+      # return false here, the MemoryPointer from to_native
+      # will be garbage collected before the struct.
+      def reference_required?
+        true
+      end
     end
   end
 end

data/lib/spotify/types/utf8_string.rb

@@ -8,33 +8,27 @@ module Spotify
     extend FFI::DataConverter
     native_type FFI::Type::STRING
 
-    # Given a value, encodes it to UTF-8 no matter what.
-    #
-    # @note if the value is already in UTF-8, ruby does nothing
-    # @note if the given value is falsy, default behaviour is used
-    #
-    # @param [String] value
-    # @param ctx
-    # @return [String] value, but in UTF-8 if it wasn’t already
-    def self.to_native(value, ctx)
-      if value
-        value.encode('UTF-8')
-      else
-        super
+    class << self
+      # Given a value, encodes it to UTF-8 no matter what.
+      #
+      # @note if the value is already in UTF-8, ruby does nothing
+      # @note if the given value is falsy, default behaviour is used
+      #
+      # @param [String, nil] value
+      # @param ctx
+      # @return [String] value, but in UTF-8 if it wasn’t already
+      def to_native(value, ctx)
+        value && value.encode('UTF-8')
       end
-    end
 
-    # Given an original string, assume it is in UTF-8.
-    #
-    # @note NO error checking is made, the string is just forced to UTF-8
-    # @param [String] value can be in any encoding
-    # @param ctx
-    # @return [String] value, but with UTF-8 encoding
-    def self.from_native(value, ctx)
-      if value
-        value.force_encoding('UTF-8')
-      else
-        super
+      # Given an original string, assume it is in UTF-8.
+      #
+      # @note NO error checking is made, the string is just forced to UTF-8
+      # @param [String] value can be in any encoding
+      # @param ctx
+      # @return [String] value, but with UTF-8 encoding
+      def from_native(value, ctx)
+        value && value.force_encoding('UTF-8')
       end
     end
   end

data/lib/spotify/util.rb

@@ -30,6 +30,7 @@ class << Spotify::API
     when /mswin/  then :windows
     else
       $stderr.puts "[WARN] You are running the Spotify gem on an unknown platform. (#{__FILE__}:#{__LINE__})"
+      $stderr.puts "[WARN] Platform: #{FFI::Platform::OS}"
       :unknown
     end
   end

data/lib/spotify/version.rb

@@ -1,9 +1,8 @@
 module Spotify
   # @note See README for versioning policy.
   # @return [String] Spotify gem version.
-  VERSION = '12.3.0'
+  VERSION = '12.4.0'
 
-  # @note May or may not work with other versions.
   # @return [String] Compatible libspotify API version.
   API_VERSION = '12.1.51'
 end

data/spec/bench_helper.rb

@@ -0,0 +1,29 @@
+require 'spotify'
+require 'benchmark'
+require 'pry'
+
+$__benchmarks__ = []
+
+def bench(name, iterations = 100_000, &block)
+  file, line, _ = caller[0].split(':')
+  $__benchmarks__ << {
+    file: File.basename(file),
+    line: line,
+    name: name,
+    iterations: iterations,
+    block: block
+  }
+end
+
+at_exit do
+  Benchmark.bmbm do |x|
+    $__benchmarks__.each do |info|
+      benchname = "#{info[:file]}:#{info[:line]} #{info[:name]}"
+      x.report(benchname) { info[:iterations].times(&info[:block]) }
+    end
+  end
+end
+
+Dir["./**/*_bench.rb"].each do |benchmark|
+  require benchmark
+end

data/spec/benchmarks/managed_pointer_bench.rb

@@ -0,0 +1,32 @@
+module Spotify
+  class << API
+    def bogus_add_ref(x)
+    end
+
+    def bogus_release(x)
+    end
+  end
+
+  class Bogus < ManagedPointer
+  end
+end
+
+one   = FFI::Pointer.new(1)
+null  = FFI::Pointer::NULL
+
+album = Spotify::Album.new(one)
+album.autorelease = false
+
+bench "Album#to_native" do
+  Spotify::Album.to_native(album, nil)
+end
+
+bench "Bogus#retain" do
+  Spotify::Bogus.retain(one)
+  Spotify::Bogus.retaining_class.retain(one)
+end
+
+bench "Bogus#release" do
+  Spotify::Bogus.release(one)
+  Spotify::Bogus.retaining_class.release(one)
+end