spotify 12.5.3 → 12.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d9e97a03f155c02b4b189899d152e51acc80c21
-  data.tar.gz: 43731fc0330043a6885b08c669c2fb13418efb68
+  metadata.gz: 8e5e929a7c03551703eebf95485b6f4fc8d91d2b
+  data.tar.gz: 329f09f809e753dd0993bcd51c95dfcedeb84e13
 SHA512:
-  metadata.gz: 519bd5a79bb4a76dd63cb2ad884cb42da3a7bc142cf851db490bdc6f35f21be15fc224911f80650a437e7152db3cd0ad4901ce25e0d62f414aea8aec900447cf
-  data.tar.gz: f0b4bc4da8b176121aa4cb62c276142086084e8d8334fc291d76a740693ec218f170c6cf478023d0a971b04a27c68fab07b80f7a14c1c6625f66fbe00f1c5fbb
+  metadata.gz: 929d6bfcdec85e642e301f6278d9b2c52cf42975304ad0fc5aa7fbceee404af6dbf9598011a9bc8d43921d7a95d97f9f1ed41b6cbd41cdf10c872f6bdb4e92f2
+  data.tar.gz: fd761313e677f2556992ca4fde3fb2fe27bcb9e7af5af1b2de1b30c425b0647ef1241ce5bfaaf18e0774d216fa15132b81af05979e3d2115a8812fa72813f7f1

data/.gitignore

@@ -7,3 +7,5 @@ doc/
 .yardoc
 .rbx
 *.rbc
+.spotify/
+spotify_appkey.key

data/.travis.yml

@@ -1,6 +1,21 @@
+language: ruby
+script: "bundle exec ruby -W -S rspec spec"
+cache: bundler
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
-  - rbx-19mode
-  - jruby-19mode
+  - 2.0
+  - 2.1
+  - ruby-head
+  - rbx-2
+  - jruby
+env:
+  - RUBY_PLATFORM="x86_64-linux"
+  - RUBY_PLATFORM="x86_64-darwin11.3.0"
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+notifications:
+  email:
+    recipients:
+      - kim@burgestrand.se
+    on_success: change
+    on_failure: change

data/CHANGELOG.md

@@ -1,6 +1,34 @@
 [HEAD][]
 -----------
 
+This change features a few large improvements:
+
+- A bunch of API calls have been improved to remove FFI pointer juggling. Methods
+  such as e.g. #session_create, or #link_as_string are now much easier to use. See
+  https://github.com/Burgestrand/spotify/issues/19 for more details.
+- Documentation has been much improved by (more or less) copying documentation
+  from libspotify docs, and adding some notes and examples to it.
+- All API calls are now called in a specific background thread, powered by the
+  [Performer](https://rubygems.org/gems/performer) gem. This replaces the previous
+  mutex lock around all API calls, and possibly fixes a lot of random deadlocks.
+  See https://github.com/Burgestrand/spotify/issues/23.
+- API reference documentation (YARD) has been added to all methods.
+- Errors are no longer symbols, but actual errors inheriting from Spotify::APIError
+
+Keep in mind that these changes are not backwards-compatible.
+
+- [d80b9249] Make one class for each kind of error, instead of using symbols
+- [0da56807] Move utility methods to Spotify::Util
+- [72ee2526] Officially drop support for Ruby 1.9
+- [dc492876] Perform *all* API calls in a specific Spotify thread
+- [f5244743] A warning is now displayed on API mismatch instead of an error
+- [dda1bc53] null pointers have been replaced by `nil`
+- [98b5b1e0] Automatically encode country codes in #session_user_country
+- [c8ad624e] Add #code and #symbol to Spotify::Error
+- [77d1b978] Do not raise an error in Spotify.try when the resource is loading
+- [f8293775] Print to stderr instead of stdout when libspotify cannot be found
+- [c7042db6] Added Spotify.log (private API)
+
 [v12.5.3][]
 -----------
 
@@ -208,7 +236,7 @@ v0.0.0
 
 [HEAD]: https://github.com/Burgestrand/spotify/compare/v12.5.3...HEAD
 
-[v12.5.2]: https://github.com/Burgestrand/spotify/compare/v12.5.2...v12.5.3
+[v12.5.3]: https://github.com/Burgestrand/spotify/compare/v12.5.2...v12.5.3
 [v12.5.2]: https://github.com/Burgestrand/spotify/compare/v12.5.1...v12.5.2
 [v12.5.1]: https://github.com/Burgestrand/spotify/compare/v12.5.0...v12.5.1
 [v12.5.0]: https://github.com/Burgestrand/spotify/compare/v12.4.0...v12.5.0

data/Gemfile

@@ -6,3 +6,8 @@ gem 'pry'
 gem 'yard'
 gem 'maruku'
 gem "plaything", "~> 1.1"
+
+platform :rbx do
+  gem "rubysl"
+  gem "racc"
+end

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+License
+-------
+Copyright (c) 2011-2013 Kim Burgestrand <kim@burgestrand.se>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -20,85 +20,110 @@ The Spotify gem has:
 
 - [100% API coverage][], including callback support. You’ll be able to use any function from the libspotify library.
 - [Automatic garbage collection][]. Piggybacking on Ruby’s GC to manage pointer lifecycle.
-- [Parallell function call protection][]. libspotify is not thread-safe, but Spotify protects you by providing a re-entrant mutex around function calls.
+- [Parallell function call protection][]. libspotify is not thread-safe, but Spotify protects you by making all API calls in a specific background thread.
 - [Type conversion and type safety][]. Special pointers for every Spotify type, protecting you from accidental mix-ups.
-- [Support for JRuby and Rubinius][]. Thanks to FFI, the gem runs fine on the main three Ruby implementations!
+- [Support for Ruby, JRuby and Rubinius][]. Thanks to FFI, the gem runs fine on the main three Ruby implementations!
 
 [100% API coverage]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API
 [Automatic garbage collection]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/ManagedPointer
 [Parallell function call protection]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify#method_missing-class_method
 [Type conversion and type safety]: http://rdoc.info/github/Burgestrand/spotify/master/Spotify/ManagedPointer
-[Support for JRuby and Rubinius]: https://github.com/Burgestrand/spotify/blob/master/.travis.yml
+[Support for Ruby, JRuby and Rubinius]: https://github.com/Burgestrand/spotify/blob/master/.travis.yml
 
 Contact details
 ---------------
 
-- __Got questions?__ Ask on the mailing list: [ruby-hallon@googlegroups.com][] (<https://groups.google.com/d/forum/ruby-hallon>)
+- __Got questions?__ Ask on the mailing list: [ruby-spotify@googlegroups.com][] (<https://groups.google.com/d/forum/ruby-spotify>)
 - __Found a bug?__ Report an issue: <https://github.com/Burgestrand/spotify/issues/new>
 - __Have feedback?__ I ❤ feedback! Please send it to the mailing list.
 
-Spotify API is best used with a supporting library
---------------------------------------------------
-As the raw libspotify API is exposed, the Spotify gem is best coupled with a supporting
-library. This library would take a more focused approach to which kind of applications
-you can write using it. The Spotify gem itself, however, has very few opinions.
+Questions, notes and answers
+----------------------------
 
-Known supporting libraries:
+### Links to keep close at hand when using libspotify
 
-- [Hallon](https://github.com/Burgestrand/Hallon). Hallon attempted to be a one-gem-does-all,
-  at a higher abstraction level than the Spotify gem. It features a slightly more convenient
-  API for certain things, and requires no ruby FFI knowledge, but it is not really an expert
-  on any use case.
+- [spotify gem API reference](http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API) — YARDoc reference for the spotify gem, maps to the [libspotify function list](https://developer.spotify.com/docs/libspotify/12.1.51/api_8h.html).
+- [libspotify C API reference](https://developer.spotify.com/docs/libspotify/12.1.51/) — the one true source of documentation.
+- [libspotify FAQ](https://developer.spotify.com/technologies/libspotify/faq/) — you should read this at least once.
+- [spotify gem examples](https://github.com/Burgestrand/spotify/tree/master/examples) — located in the spotify gem repository.
+- [spotify gem FAQ](#questions-notes-and-answers) — this README section.
 
-The Spotify API is well suited for experimentation, and it can be awfully fun to play with.
-The examples/ directory contains example code for achieving certain tasks with the Spotify gem.
 
-If you need any assitance feel free to post a message on the mailing list: [ruby-hallon@googlegroups.com][].
+### How to run the examples
 
-Manually installing libspotify
-------------------------------
-By default, Spotify uses [the libspotify gem](https://rubygems.org/gems/libspotify) which means you do
-not need to install libspotify yourself. However, if your platform is not supported by the libspotify
-gem you will need to install libspotify yourself.
+You’ll need:
 
-Please note, that if your platform is not supported by the libspotify gem I’d very much appreciate it
-if you could create an issue on [libspotify gem issue tracker](https://github.com/Burgestrand/libspotify/issues)
-so I can fix the build for your platform.
+1. Your [Spotify](http://spotify.com/) premium account credentials. If you sign in with Facebook, you’ll need your Facebook account e-mail and password.
+2. Your [Spotify application key](https://developer.spotify.com/technologies/libspotify/keys/). Download the binary key, and put it in the `examples/` directory.
+
+Running the examples is as simple as:
+
+```
+ruby example-audio_stream.rb
+```
+
+Available examples are:
+
+- **example-audio_stream.rb**: plays songs from Spotify with the [plaything](https://github.com/Burgestrand/plaything) gem, using OpenAL.
+- **example-console.rb**: logs in to Spotfify, and initiates a pry session to allow experimentation with the spotify gem API.
+- **example-listing_playlists.rb**: list all playlists available for a certain user.
+- **example-loading_object.rb**: loads a track using polling and the spotify gem API.
+- **example-random_related_artists.rb**: looks up an artist and its similar artists on spotify, then it picks a similar artist at random and does the same to that artist, over and over. I have used this example file to test prolonged usage of the API.
+
+### Creating a Session, the first thing you should do
+
+Almost all functions require you to have created a session before calling them. Forgetting to do so won’t work at best, and will segfault at worst. You'll also want to log in before doing things as well, or objects will never load.
+
+See [Spotify::API#session_create](http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API#session_create-instance_method) for how to create a session.
+See [Spotify::API#session_login](http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API#session_login-instance_method) for logging in.
+
+### libspotify is an asynchronous library
+
+When creating objects in libspotify they are not populated with data instantly, instead libspotify schedules them for download from the Spotify backend. For libspotify to do it's work with downloading content, you need to call [Spotify::API#session_process_events](http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API#session_process_events-instance_method) regularly.
+
+### Facebook vs Spotify Classic
 
-While you’re waiting for the issue to resolve you could install libspotify manually. I’ve provided
-instructions on how to do this in Hallon’s wiki: [How to install libspotify](https://github.com/Burgestrand/Hallon/wiki/How-to-install-libspotify)!
+Users who signed up to Spotify with their Facebook account will have numeric IDs as usernames, so a link to their profile looks like [spotify:user:11101648092](spotify:user:11101648092). Spotify Classic users instead have their usernames as canonical name, so a link to their profile looks like [spotify:user:burgestrand](spotify:user:burgestrand).
+
+This matters, for example, when you use the function [Spotify::API#session_publishedcontainer_for_user_create](http://rdoc.info/github/Burgestrand/spotify/master/Spotify/API#session_publishedcontainer_for_user_create-instance_method).
+
+### Callbacks can be dangerous
+
+libspotify allows you to pass callbacks that will be invoked by libspotify when events of interest occur, such as being logged out, or receiving audio data when playing a track.
+
+Callbacks can be very tricky. They must never be garbage collected while they are in use by libspotify, or you may get very weird bugs with your Ruby interpreter randomly crashing. Do use them, but be careful.
+
+### Opinions and the Spotify gem
+
+The Spotify gem has very few opinions. It is build to closely resemble the libspotify C API, and has very little
+to aid you in terms of how to structure your application. It aims to make calling the libspotify C API frictionless,
+but not much more. It is up to you to decide your own path.
+
+### A note about gem versioning
 
-A note about versioning scheme
-------------------------------
 Given a version `X.Y.Z`, each segment corresponds to:
 
-- X reflects supported libspotify version (12.1.45 => 12). There are __no guarantees__ of backwards-compatibility!
-- Y(major).Z(minor) follows [semantic versioning (semver.org)][]. Y is for backwards-**incompatible** changes, Z is for backwards-**compatible** changes.
+- `X` reflects supported libspotify version (12.1.45 => 12). There are __no guarantees__ of backwards-compatibility!
+- `Y` is for backwards-**incompatible** changes.
+- `Z` is for backwards-**compatible** changes.
+
+You should use the following version constraint: `gem "spotify", "~> 12.5.3"`.
 
-License
--------
-Copyright (c) 2012 Kim Burgestrand <kim@burgestrand.se>
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+### Manually installing libspotify
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+By default, Spotify uses [the libspotify gem](https://rubygems.org/gems/libspotify) which means you do
+not need to install libspotify yourself. However, if your platform is not supported by the libspotify
+gem you will need to install libspotify yourself.
+
+Please note, that if your platform is not supported by the libspotify gem I’d very much appreciate it
+if you could create an issue on [libspotify gem issue tracker](https://github.com/Burgestrand/libspotify/issues)
+so I can fix the build for your platform.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+Instructions on installing libspotify manually are in the wiki: [How to install libspotify](https://github.com/Burgestrand/spotify/wiki)
 
 [semantic versioning (semver.org)]: http://semver.org/
-[ruby-hallon@googlegroups.com]: mailto:ruby-hallon@googlegroups.com
+[ruby-spotify@googlegroups.com]: mailto:ruby-spotify@googlegroups.com
 [libspotify]: https://developer.spotify.com/technologies/libspotify/
 [Spotify]: https://www.spotify.com/
 [Hallon]: https://github.com/Burgestrand/Hallon

data/Rakefile

@@ -33,7 +33,7 @@ task :gen do
 end
 
 task :console do
-  exec "irb", "-Ilib", "-rspotify"
+  exec "pry", "-Ilib", "-rspotify"
 end
 
 require 'rspec/core/rake_task'

data/examples/example-audio_delivery_speed.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# NOTE: this example is merely here to count how fast audio frames
+# can be delivered. It does not do anything useful.
+
+require_relative "support"
+require "json"
+
+$frames = 0
+$rate = 0
+
+Support::DEFAULT_CONFIG[:callbacks] = Spotify::SessionCallbacks.new({
+  music_delivery: proc do |session, format, frames, num_frames|
+    $rate = format[:sample_rate]
+    $frames += num_frames
+    num_frames
+  end,
+
+  end_of_track: proc do |session|
+    puts "End of track!"
+    $end_of_track = true
+  end
+})
+
+session = Support.initialize_spotify!
+
+link = Spotify.link_create_from_string("spotify:track:1Lm5kdSQX6x1uVz6ep3AIk")
+track = Spotify.link_as_track(link)
+
+Support.poll(session) { Spotify.track_is_loaded(track) }
+
+Spotify.try(:session_player_load, session, track)
+Spotify.try(:session_player_play, session, true)
+
+measurer = Thread.new do
+  loop do
+    if $rate
+      frames, $frames = $frames, 0
+      puts "#{frames}f of #{$rate}f/s (#{frames.fdiv($rate).round(2)}s)"
+    end
+    sleep 1
+  end
+end
+
+$logger.info "Playing track until end. Use ^C to exit."
+Support.silenced = true
+Support.poll(session) { $end_of_track }

data/examples/{audio-stream_example.rb → example-audio_stream.rb}

@@ -1,18 +1,20 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
-require_relative "example_support"
+require_relative "support"
 
 require "json"
 require "plaything"
 
-def play_track(uri)
+def play_track(session, uri)
   link = Spotify.link_create_from_string(uri)
   track = Spotify.link_as_track(link)
-  Support.poll($session) { Spotify.track_is_loaded(track) }
-  Spotify.try(:session_player_play, $session, false)
-  Spotify.try(:session_player_load, $session, track)
-  Spotify.try(:session_player_play, $session, true)
+  Support.poll(session) { Spotify.track_is_loaded(track) }
+
+  # Pause before we load a new track. Fixes a quirk in libspotify.
+  Spotify.try(:session_player_play, session, false)
+  Spotify.try(:session_player_load, session, track)
+  Spotify.try(:session_player_play, session, true)
 end
 
 class FrameReader
@@ -55,7 +57,7 @@ $session_callbacks = {
   end,
 
   logged_in: proc do |session, error|
-    $logger.debug("session (logged in)") { Spotify::Error.explain(error) }
+    $logger.debug("session (logged in)") { error.message }
   end,
 
   logged_out: proc do |session|
@@ -63,7 +65,7 @@ $session_callbacks = {
   end,
 
   streaming_error: proc do |session, error|
-    $logger.error("session (player)") { "streaming error %s" % Spotify::Error.explain(error) }
+    $logger.error("session (player)") { "streaming error %s" % error.message }
   end,
 
   start_playback: proc do |session|
@@ -109,28 +111,11 @@ $session_callbacks = {
 # You can read about what these session configuration options do in the
 # libspotify documentation:
 # https://developer.spotify.com/technologies/libspotify/docs/12.1.45/structsp__session__config.html
-config = Spotify::SessionConfig.new({
-  api_version: Spotify::API_VERSION.to_i,
-  application_key: $appkey,
-  cache_location: ".spotify/",
-  settings_location: ".spotify/",
-  tracefile: "spotify_tracefile.txt",
-  user_agent: "spotify for ruby",
-  callbacks: Spotify::SessionCallbacks.new($session_callbacks),
-})
-
-$logger.info "Creating session."
-$session = Support.create_session(config)
-
-$logger.info "Created! Logging in."
-Spotify.session_login($session, $username, $password, false, $blob)
-
-$logger.info "Log in requested. Waiting forever until logged in."
-Support.poll($session) { Spotify.session_connectionstate($session) == :logged_in }
+Support::DEFAULT_CONFIG[:callbacks] = Spotify::SessionCallbacks.new($session_callbacks)
 
-$logger.info "Logged in as #{Spotify.session_user_name($session)}."
+session = Support.initialize_spotify!
 
-play_track Support.prompt("Spotify track URI")
+play_track(session, Support.prompt("Spotify track URI", "spotify:track:5iIeIeH3LBSMK92cMIXrVD"))
 
 $logger.info "Playing track until end. Use ^C to exit."
-Support.poll($session) { $end_of_track }
+Support.poll(session) { $end_of_track }

data/examples/example-console.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require_relative "support"
+
+session = Support.initialize_spotify!
+
+$logger.info "Logged in as #{Spotify.session_user_name(session)}! Entering interactive session…"
+binding.pry

data/examples/example-listing_playlists.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require_relative "support"
+
+session = Support.initialize_spotify!
+
+username = Support.prompt("Please enter a username", "burgestrand")
+
+# libspotify has no way of searching for users by name or e-mail, so
+# this is the only way I know of to get a handle of a user from nothing,
+# and probably won't work for users that do not have a classic Spotify
+# username, i.e. users that only signed up through Facebook.
+#
+# If you can get a handle on a playlist created by that user, you'll be
+# able to get the handle for them, but not otherwise!
+#
+# For users that signed up through Facebook only, I believe their Facebook
+# user ID should work with this lookup.
+user_link = "spotify:user:#{username}"
+link = Spotify.link_create_from_string(user_link)
+
+if link.null?
+  $logger.error "#{user_link} was apparently not parseable as a Spotify URI. Aborting."
+  abort
+end
+
+user = Spotify.link_as_user(link)
+$logger.info "Attempting to load #{user_link}. Waiting forever until successful."
+Support.poll(session) { Spotify.user_is_loaded(user) }
+
+display_name = Spotify.user_display_name(user)
+canonical_name = Spotify.user_canonical_name(user)
+$logger.info "User loaded: #{display_name}."
+
+$logger.info "Loading user playlists by loading their published container: #{canonical_name}."
+container = Spotify.session_publishedcontainer_for_user_create(session, canonical_name)
+
+$logger.info "Attempting to load container. Waiting forever until successful."
+Support.poll(session) { Spotify.playlistcontainer_is_loaded(container) }
+
+$logger.info "Container loaded. Loading playlists until no more are loaded for three tries!"
+
+container_size = 0
+previous_container_size = 0
+break_counter = 0
+
+loop do
+  container_size = Spotify.playlistcontainer_num_playlists(container)
+  new_playlists = container_size - previous_container_size
+  previous_container_size = container_size
+  $logger.info "Loaded #{new_playlists} more playlists."
+
+  # If we have loaded no new playlists for 4 tries, we assume we are done.
+  if new_playlists == 0
+    break_counter += 1
+    if break_counter >= 4
+      break
+    end
+  end
+
+  $logger.info "Loading…"
+  5.times do
+    Support.process_events(session)
+    sleep 0.2
+  end
+end
+
+$logger.info "#{container_size} published playlists for #{display_name} found. Loading each playlists and printing it."
+container_size.times do |index|
+  type = Spotify.playlistcontainer_playlist_type(container, index)
+  playlist = Spotify.playlistcontainer_playlist(container, index)
+  Support.poll(session) { Spotify.playlist_is_loaded(playlist) }
+
+  playlist_name = Spotify.playlist_name(playlist)
+  num_tracks = Spotify.playlist_num_tracks(playlist)
+
+  # Retrieving link for playlist:
+  playlist_link = Spotify.link_create_from_playlist(playlist)
+  link_string = if playlist_link.nil?
+    "(no link)"
+  else
+    Spotify.link_as_string(playlist_link)
+  end
+
+  $logger.info "  (#{type}) #{playlist_name}: #{link_string} (#{num_tracks} tracks)"
+end
+
+$logger.info "All done."