exportify 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba4e32c9eef691c03687d84d69a6ec48824d168dd94411ae78a15c9461165bde
+  data.tar.gz: cb5c7a23841c1b3717afa071b48d6401814f425caae4e3fe4af08bbe4c01eb29
+SHA512:
+  metadata.gz: d579e82f30b6437fbc89499e153559c6f8b3ab1b9ce05a805a35280bc6386ac1ee4eb16ce1e0f183a9a0cec9e285e00715ab0dd5dcb429fcfc7cf13fbe1c9cba
+  data.tar.gz: 28b1fb6b4133f5924285a6e1b14f90d25fd002b6ce0e72b23a393c9c62084547fff452a2936f0a2edd1e0f528324c116a843491f38a1ae53b01ffd11a5bf32f6

data/README.md

@@ -0,0 +1,106 @@
+# Exportify
+
+Downloads a Spotify playlist as MP3 files with proper ID3 tags (title, artist, album, year, track number, genre).
+
+## Requirements
+
+- Ruby 3.3+
+- [yt-dlp](https://github.com/yt-dlp/yt-dlp) — `brew install yt-dlp`
+- Python 3 + [mutagen](https://mutagen.readthedocs.io/) — `pip3 install mutagen`
+- A Spotify Developer application
+
+## Setup
+
+1. Crie um app em [developer.spotify.com](https://developer.spotify.com/dashboard).
+2. Adicione `http://127.0.0.1:8888/callback` como Redirect URI nas configurações do app.
+3. Instale as dependências:
+
+```sh
+bundle install
+```
+
+4. Execute o setup interativo:
+
+```sh
+bin/exportify init
+```
+
+```
+=== Exportify Setup ===
+
+Diretório principal [musics]: ~/Music
+Spotify Client ID: <seu client id>
+Spotify Client Secret: ████████
+
+Configuração salva em ~/.exportify
+```
+
+As credenciais e o diretório ficam salvos em `~/.exportify` (permissão `600`). Para reconfigurar qualquer campo, execute `init` novamente — Enter em branco mantém o valor atual.
+
+> **Alternativa:** as variáveis de ambiente `SPOTIFY_CLIENT_ID` e `SPOTIFY_CLIENT_SECRET` têm prioridade sobre o arquivo de configuração, útil em ambientes de CI.
+
+## Usage
+
+### Baixar uma playlist
+
+```sh
+bin/exportify https://open.spotify.com/playlist/<playlist_id>
+```
+
+Os arquivos são organizados em subdiretórios pelo nome da playlist:
+
+```
+musics/
+  Rock dos Anos 80/
+    Queen - Bohemian Rhapsody.mp3
+    David Bowie - Heroes.mp3
+  Trap Brasil/
+    ...
+```
+
+Faixas que já existem no disco são ignoradas automaticamente. Rodar o comando novamente após adicionar músicas à playlist baixa apenas as novas.
+
+### Sincronização bidirecional
+
+Para remover do disco as músicas que foram retiradas da playlist:
+
+```sh
+bin/exportify https://open.spotify.com/playlist/<playlist_id> --sync
+```
+
+### Regravar tags ID3
+
+Para atualizar as tags dos arquivos já baixados sem rebaixar:
+
+```sh
+bin/exportify https://open.spotify.com/playlist/<playlist_id> --retag
+```
+
+## Desenvolvimento
+
+```sh
+bundle exec rake test      # testes
+bundle exec rubocop        # lint
+bundle exec bundler-audit check --update  # vulnerabilidades em dependências
+```
+
+O CI roda os três automaticamente a cada push.
+
+## Release
+
+Para publicar uma nova versão no RubyGems:
+
+1. Atualize `lib/exportify/version.rb`
+2. Crie e faça push da tag:
+
+```sh
+git tag v1.0.0
+git push --tags
+```
+
+O workflow de release dispara automaticamente e publica a gem. Requer o secret `RUBYGEMS_API_KEY` configurado em Settings → Secrets → Actions do repositório.
+
+## Notas
+
+- O token OAuth é cacheado em `~/.exportify_token.json` e renovado automaticamente quando expira. Se a sessão for revogada, o arquivo é removido e um novo login é solicitado.
+- Playlists de artistas oficiais ou gravadoras podem retornar erro 403 — isso é uma restrição da API do Spotify para apps de terceiros sem acesso estendido.

data/bin/exportify

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'exportify'
+
+Exportify::CLI.run(ARGV)

data/exportify.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lib/exportify/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'exportify'
+  spec.version     = Exportify::VERSION
+  spec.authors     = ['Caio Santos']
+  spec.email       = ['caiovitor.santos@gmail.com']
+
+  spec.summary     = 'Download Spotify playlists as MP3 files with proper ID3 tags'
+  spec.description = 'Exportify authenticates with Spotify via OAuth, fetches all tracks ' \
+                     'from a playlist, downloads each one as an MP3 using yt-dlp, and ' \
+                     'writes accurate ID3 tags (title, artist, album, year, track number) ' \
+                     'via mutagen.'
+
+  spec.required_ruby_version = '>= 3.3'
+
+  spec.files         = Dir['lib/**/*.rb', 'bin/*', 'README.md', 'exportify.gemspec']
+  spec.bindir        = 'bin'
+  spec.executables   = ['exportify']
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'base64',  '~> 0.2'
+  spec.add_dependency 'webrick', '~> 1.9'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/exportify/auth.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'net/http'
+require 'json'
+require 'uri'
+require 'base64'
+require 'webrick'
+require_relative 'config'
+
+module Exportify
+  module Auth
+    TOKEN_FILE   = File.expand_path('~/.exportify_token.json')
+    REDIRECT_URI = 'http://127.0.0.1:8888/callback'
+    SCOPES       = 'playlist-read-private playlist-read-collaborative'
+
+    module_function
+
+    def save_token(data)
+      data['expires_at'] = Time.now.to_i + data['expires_in'].to_i
+      File.write(TOKEN_FILE, JSON.generate(data))
+      data
+    end
+
+    def load_token
+      return nil unless File.exist?(TOKEN_FILE)
+
+      JSON.parse(File.read(TOKEN_FILE))
+    end
+
+    def refresh_token(token_data)
+      uri = URI('https://accounts.spotify.com/api/token')
+      req = Net::HTTP::Post.new(uri)
+      req['Authorization'] = "Basic #{Base64.strict_encode64("#{client_id}:#{client_secret}")}"
+      req.set_form_data(
+        'grant_type' => 'refresh_token',
+        'refresh_token' => token_data['refresh_token']
+      )
+      res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
+      data = JSON.parse(res.body)
+      handle_token_error!(data)
+      data['refresh_token'] ||= token_data['refresh_token']
+      save_token(data)
+    end
+
+    def exchange_code(code)
+      uri = URI('https://accounts.spotify.com/api/token')
+      req = Net::HTTP::Post.new(uri)
+      req['Authorization'] = "Basic #{Base64.strict_encode64("#{client_id}:#{client_secret}")}"
+      req.set_form_data(
+        'grant_type' => 'authorization_code',
+        'code' => code,
+        'redirect_uri' => REDIRECT_URI
+      )
+      res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
+      data = JSON.parse(res.body)
+      handle_token_error!(data)
+      save_token(data)
+    end
+
+    def handle_token_error!(data)
+      return unless data['error']
+
+      case data['error']
+      when 'invalid_client'
+        abort 'Erro de autenticação: SPOTIFY_CLIENT_ID ou SPOTIFY_CLIENT_SECRET inválidos.'
+      when 'invalid_grant'
+        FileUtils.rm_f(TOKEN_FILE)
+        abort "Sessão expirada ou revogada. Arquivo de token removido.\nExecute o comando novamente para fazer login."
+      else
+        abort "Erro ao obter token Spotify: #{data['error']} — #{data['error_description']}"
+      end
+    end
+
+    def authorize!
+      params = URI.encode_www_form(
+        client_id: client_id,
+        response_type: 'code',
+        redirect_uri: REDIRECT_URI,
+        scope: SCOPES
+      )
+      url = "https://accounts.spotify.com/authorize?#{params}"
+
+      puts "\nAbrindo navegador para login no Spotify..."
+      puts "Se não abrir automaticamente, acesse:\n#{url}\n"
+      system("open '#{url}'")
+
+      code   = nil
+      server = WEBrick::HTTPServer.new(
+        Port: 8888,
+        BindAddress: '127.0.0.1',
+        Logger: WEBrick::Log.new(File::NULL),
+        AccessLog: []
+      )
+      server.mount_proc('/callback') do |req, res|
+        code          = req.query['code']
+        res.body      = '<html><body><h2>Login realizado! Pode fechar esta aba.</h2></body></html>'
+        res['Content-Type'] = 'text/html'
+        server.shutdown
+      end
+      server.start
+
+      abort 'Login cancelado' unless code
+      exchange_code(code)
+    end
+
+    def access_token
+      token = load_token
+      if token.nil?
+        token = authorize!
+      elsif Time.now.to_i >= token['expires_at'].to_i - 60
+        token = refresh_token(token)
+      end
+      token['access_token']
+    end
+
+    def client_id
+      ENV.fetch('SPOTIFY_CLIENT_ID', nil) || Config.load['spotify_client_id']
+    end
+
+    def client_secret
+      ENV.fetch('SPOTIFY_CLIENT_SECRET', nil) || Config.load['spotify_client_secret']
+    end
+  end
+end

data/lib/exportify/cli.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'optparse'
+require_relative 'auth'
+require_relative 'config'
+require_relative 'spotify'
+require_relative 'downloader'
+require_relative 'tagger'
+
+module Exportify
+  module CLI
+    DEFAULT_OUTPUT_DIR = 'musics'
+
+    module_function
+
+    def run(argv)
+      return run_init(argv[1]) if argv[0] == 'init'
+
+      retag = false
+      sync  = false
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage:\n  " \
+                      "exportify init\n  " \
+                      'exportify <spotify_playlist_url> [--retag] [--sync]'
+        opts.on('--retag', 'Regravar tags ID3 nos arquivos existentes') { retag = true }
+        opts.on('--sync',  'Remover arquivos locais que não estão mais na playlist') { sync = true }
+      end
+
+      parser.parse!(argv)
+      playlist_url = argv[0]&.split('?', 2)&.first
+
+      abort parser.banner unless playlist_url
+
+      abort 'Credenciais não configuradas. Execute: exportify init' unless Auth.client_id && Auth.client_secret
+
+      playlist_id = playlist_url.match(%r{playlist/([A-Za-z0-9]+)})&.captures&.first
+      abort 'Invalid playlist URL' unless playlist_id
+
+      puts 'Authenticating with Spotify...'
+      token = Auth.access_token
+
+      puts 'Fetching playlist...'
+      name       = Spotify.playlist_name(playlist_id, token)
+      tracks     = Spotify.playlist_tracks(playlist_id, token)
+      tracks     = Spotify.enrich_with_genres(tracks, token)
+      output_dir = File.expand_path(File.join(Config.output_dir, Downloader.sanitize(name)))
+
+      FileUtils.mkdir_p(output_dir)
+
+      puts "#{tracks.size} tracks found"
+      puts "Output: #{output_dir}\n\n"
+
+      ok = skip = failed = 0
+
+      tracks.each_with_index do |track, i|
+        artist   = Downloader.sanitize(track[:artist])
+        name     = Downloader.sanitize(track[:name])
+        filename = "#{artist} - #{name}.mp3"
+        filepath = File.join(output_dir, filename)
+
+        print "[#{i + 1}/#{tracks.size}] #{filename} "
+
+        if retag
+          if File.exist?(filepath)
+            Tagger.tag(filepath, track)
+            puts '(retagged)'
+            ok += 1
+          else
+            puts '(not found, skipping)'
+            skip += 1
+          end
+          next
+        end
+
+        if File.exist?(filepath)
+          puts '(already exists, skipping)'
+          skip += 1
+          next
+        end
+
+        puts '(downloading...)'
+        success = Downloader.download(track, output_dir)
+
+        if success && File.exist?(filepath)
+          Tagger.tag(filepath, track)
+          ok += 1
+        else
+          failed += 1
+        end
+      end
+
+      removed = 0
+
+      if sync
+        expected = tracks.to_set do |track|
+          "#{Downloader.sanitize(track[:artist])} - #{Downloader.sanitize(track[:name])}.mp3"
+        end
+
+        Dir.glob(File.join(output_dir, '*.mp3')).each do |file|
+          next if expected.include?(File.basename(file))
+
+          puts "Removing #{File.basename(file)}"
+          File.delete(file)
+          removed += 1
+        end
+      end
+
+      if retag
+        puts "\nDone: #{ok} retagged, #{skip} not found."
+      else
+        removed_msg = sync ? ", #{removed} removed" : ''
+        puts "\nDone: #{ok} downloaded, #{skip} skipped, #{failed} failed#{removed_msg}."
+      end
+    end
+
+    def run_init(dir = nil)
+      require 'io/console'
+
+      cfg = Config.load
+      tty = open_tty
+
+      puts '=== Exportify Setup ==='
+      puts
+
+      default_dir = dir || cfg.fetch('output_dir', DEFAULT_OUTPUT_DIR)
+      print "Diretório principal [#{default_dir}]: "
+      dir_input = tty.gets.chomp
+      new_dir   = dir_input.empty? ? default_dir : dir_input
+
+      current_id = cfg['spotify_client_id'] || ''
+      id_hint    = current_id.empty? ? '' : " [#{current_id[0..7]}...]"
+      print "Spotify Client ID#{id_hint}: "
+      id_input = tty.gets.chomp
+      new_id   = id_input.empty? ? current_id : id_input
+
+      secret_hint = cfg['spotify_client_secret'] ? ' [configurado]' : ''
+      print "Spotify Client Secret#{secret_hint}: "
+      new_secret = read_secret(tty)
+      puts
+      new_secret = cfg['spotify_client_secret'] if new_secret.empty?
+
+      abort 'Client ID não pode ser vazio.' if new_id.empty?
+      abort 'Client Secret não pode ser vazio.' if new_secret.to_s.empty?
+
+      Config.save(
+        'output_dir' => File.expand_path(new_dir),
+        'spotify_client_id' => new_id,
+        'spotify_client_secret' => new_secret
+      )
+
+      puts "\nConfiguração salva em #{Config::CONFIG_PATH}"
+    ensure
+      tty&.close
+    end
+
+    def open_tty
+      IO.console || $stdin
+    end
+
+    def read_secret(tty)
+      if tty.respond_to?(:noecho)
+        tty.noecho(&:gets).chomp
+      else
+        tty.gets.chomp
+      end
+    end
+  end
+end

data/lib/exportify/config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Exportify
+  module Config
+    CONFIG_PATH = File.expand_path('~/.exportify')
+
+    module_function
+
+    def load
+      return {} unless File.exist?(CONFIG_PATH)
+
+      JSON.parse(File.read(CONFIG_PATH))
+    rescue JSON::ParserError
+      {}
+    end
+
+    def save(data)
+      File.write(CONFIG_PATH, JSON.pretty_generate(load.merge(data)))
+      File.chmod(0o600, CONFIG_PATH)
+    end
+
+    def output_dir
+      load['output_dir'] || CLI::DEFAULT_OUTPUT_DIR
+    end
+  end
+end

data/lib/exportify/downloader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Exportify
+  module Downloader
+    module_function
+
+    def download(track, output_dir)
+      artist   = sanitize(track[:artist])
+      name     = sanitize(track[:name])
+      query    = "#{track[:raw_name]} #{track[:all_artists]} official audio"
+      template = File.join(output_dir, "#{artist} - #{name}.%(ext)s")
+
+      system(
+        'yt-dlp', "ytsearch1:#{query}",
+        '--extract-audio', '--audio-format', 'mp3', '--audio-quality', '0',
+        '--output', template,
+        '--no-playlist', '--quiet', '--no-warnings'
+      )
+    end
+
+    def sanitize(str)
+      str.gsub(%r{[/\\:*?"<>|]}, '').strip
+    end
+  end
+end

data/lib/exportify/spotify.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Exportify
+  module Spotify
+    module_function
+
+    def playlist_name(playlist_id, token)
+      uri = URI("https://api.spotify.com/v1/playlists/#{playlist_id}?fields=name")
+      req = Net::HTTP::Get.new(uri)
+      req['Authorization'] = "Bearer #{token}"
+      res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
+      data = JSON.parse(res.body)
+      handle_error!(data['error'], 'playlist')
+      data['name']
+    end
+
+    def playlist_tracks(playlist_id, token)
+      tracks = []
+      url    = "https://api.spotify.com/v1/playlists/#{playlist_id}/items?limit=100"
+
+      while url
+        uri = URI(url)
+        req = Net::HTTP::Get.new(uri)
+        req['Authorization'] = "Bearer #{token}"
+        res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
+        data = JSON.parse(res.body)
+        handle_error!(data['error'], 'tracks')
+
+        data['items'].each do |item|
+          track = item['item']
+          next if track.nil? || track['name'].nil?
+
+          clean_name = track['name']
+                       .gsub(/\s*[(\[].*?[)\]]/, '')
+                       .gsub(/\s*-\s*(feat|ft)\.?.*/i, '')
+                       .strip
+
+          tracks << {
+            artist: track['artists'].first['name'],
+            artist_id: track['artists'].first['id'],
+            all_artists: track['artists'].map { |a| a['name'] }.join(', '),
+            name: clean_name,
+            raw_name: track['name'],
+            album: track.dig('album', 'name') || '',
+            year: (track.dig('album', 'release_date') || '')[0..3],
+            track_number: track['track_number'] || 0,
+            genre: ''
+          }
+        end
+
+        url = data['next']
+      end
+
+      tracks
+    end
+
+    def handle_error!(error, context)
+      return unless error
+
+      status  = error['status']
+      message = error['message']
+
+      case status
+      when 401
+        abort "Erro #{status}: token inválido ou expirado. Apague ~/.exportify_token.json e tente novamente."
+      when 403
+        abort "Erro 403 ao buscar #{context}: acesso negado pelo Spotify.\n" \
+              "Isso ocorre em playlists de artistas ou gravadoras com conteúdo protegido.\n" \
+              'Tente com uma playlist pessoal ou pública de outro usuário.'
+      when 404
+        abort 'Erro 404: playlist não encontrada. Verifique se o link está correto.'
+      else
+        abort "Erro da API Spotify (#{status}): #{message}"
+      end
+    end
+
+    def enrich_with_genres(tracks, token)
+      artist_ids = tracks.map { |t| t[:artist_id] }.uniq.compact
+      genres_by_id = {}
+
+      artist_ids.each do |artist_id|
+        uri = URI("https://api.spotify.com/v1/artists/#{artist_id}")
+        req = Net::HTTP::Get.new(uri)
+        req['Authorization'] = "Bearer #{token}"
+        res  = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
+        data = JSON.parse(res.body)
+        handle_error!(data['error'], 'artistas')
+        genres_by_id[data['id']] = (data['genres'] || []).first || ''
+      end
+
+      tracks.map { |t| t.merge(genre: genres_by_id[t[:artist_id]] || '') }
+    end
+  end
+end

data/lib/exportify/tagger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Exportify
+  module Tagger
+    module_function
+
+    def tag(filepath, track)
+      python = <<~PY
+        from mutagen.id3 import ID3, TIT2, TPE1, TALB, TDRC, TRCK, TPE2, TCON, error
+        from mutagen.mp3 import MP3
+        try:
+          tags = ID3(#{filepath.inspect})
+        except error:
+          tags = ID3()
+        tags['TIT2'] = TIT2(encoding=3, text=#{track[:raw_name].inspect})
+        tags['TPE1'] = TPE1(encoding=3, text=#{track[:all_artists].inspect})
+        tags['TPE2'] = TPE2(encoding=3, text=#{track[:artist].inspect})
+        tags['TALB'] = TALB(encoding=3, text=#{track[:album].inspect})
+        tags['TDRC'] = TDRC(encoding=3, text=#{track[:year].inspect})
+        tags['TRCK'] = TRCK(encoding=3, text=#{track[:track_number].to_s.inspect})
+        tags['TCON'] = TCON(encoding=3, text=#{track[:genre].to_s.inspect})
+        tags.save(#{filepath.inspect})
+      PY
+      system('python3', '-c', python)
+    end
+  end
+end

data/lib/exportify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Exportify
+  VERSION = '1.0.0'
+end

data/lib/exportify.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'exportify/version'
+require_relative 'exportify/auth'
+require_relative 'exportify/spotify'
+require_relative 'exportify/downloader'
+require_relative 'exportify/tagger'
+require_relative 'exportify/cli'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: exportify
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Caio Santos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Exportify authenticates with Spotify via OAuth, fetches all tracks from
+  a playlist, downloads each one as an MP3 using yt-dlp, and writes accurate ID3 tags
+  (title, artist, album, year, track number) via mutagen.
+email:
+- caiovitor.santos@gmail.com
+executables:
+- exportify
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/exportify
+- exportify.gemspec
+- lib/exportify.rb
+- lib/exportify/auth.rb
+- lib/exportify/cli.rb
+- lib/exportify/config.rb
+- lib/exportify/downloader.rb
+- lib/exportify/spotify.rb
+- lib/exportify/tagger.rb
+- lib/exportify/version.rb
+homepage:
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Download Spotify playlists as MP3 files with proper ID3 tags
+test_files: []