shellify 1.0.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dc23ed10c36ddf92d2881d109271119d606b8ea380183a1d277353f13693f16
-  data.tar.gz: d66f3374654de5851cf5565a4c2c1ede72971c80a223a2748cc8af6d2f25daf7
+  metadata.gz: 0b457f8f07a6f855b4cbb3a2839df79780b49760ad264247b6225cb5fe7d0be3
+  data.tar.gz: 5e96c98b637eccc3f1fc4e24808baf60db90deca6eb061810a5db7bddc2d14ce
 SHA512:
-  metadata.gz: 32d3d1b078e5fe7fa1877cefed381104ce05df8ac2d72b3a23ef984ebba6efac5a3e37e2f6de70c5ece2495dd16cec8228a6db385235d43a67309d78da0a0f6e
-  data.tar.gz: 8d80c7a94c9ebc89408236324e3b2f6f2f10f3ce15bb26b88a012ac9ac5d91eb6e9f198553f34646e1f43d92341a35e81f3103b04c77ce64abd4d8e513e803cd
+  metadata.gz: bd69fbf66ede7b711ca6d5c24d568272f73ee2cc4303e8a4900dac5f525118e96e9c2e9f1de69e8dad4cf9268d4da103cfc07d9454e5e6c87fab7622135d7ae6
+  data.tar.gz: f162600a265e3e6167caf78480eb9d640a1089a93c6de8deb9739b9e9ea13b639cbc617157eec14cb468cf027a5f40a083957dd651a314346f839aa53c9df162

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 Derek Povah <http://derekpovah.com>
+Copyright (c) 2022 Derek Povah <https://derekpovah.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -14,25 +14,10 @@ $ gem install shellify
 
 #### Setup
 
-1. Create a Spotify application in the [Spotify Developer Dashboard](https://developer.spotify.com/dashboard).
-1. Get your Spotify OAUTH `access_token` and `refresh_token`. (Shelilfy currently doesn't currently implement a two way OAUTH flow, but Spotify has [sample apps](https://github.com/spotify/web-api-auth-examples) that you can use  to get your initial keys. Shellify will handle exchanging refresh tokens for access tokens after initial setup.)
-1. Create two json files in `~/.config/shellify`
-    `config.json`
-    ```json
-    {
-      "client_id": "xxxxxxxxxxxxxxxx",
-      "client_secret": "xxxxxxxxxxxxxxx"
-    }
-    ```
-
-    `spotify_user.json`
-    ```json
-    {
-      "id": "spotify_user_id",
-      "token": "xxxxxxxxxxxxxxx",
-      "refresh_token": "xxxxxxxxxxxxxxx"
-    }
-    ```
+1. Create an application on the [Spotify Developer Dashboard](https://developer.spotify.com/dashboard).
+1. Add `http://localhost:8888/callback` to the Spotify Application's Redirect URIs
+1. Run `shellify configure`
+1. Run `shellify authenticate`
 
 Commands
 --------

data/lib/shellify/cli.rb

@@ -19,6 +19,32 @@ module Shellify
       program :version, Shellify::VERSION
       program :description, 'Use Spotify from the command line'
 
+      command :configure do |c|
+        c.description = 'Set the Spotify client_id and client_secret'
+        c.action do
+          client_id = ask("Spotify Client ID: ")
+          client_secret = ask("Spotify Client Secret: ") { |q| q.echo = '*' }
+          @config.client_id = client_id
+          @config.client_secret = client_secret
+          @config.save!
+        end
+      end
+
+      command :authenticate do |c|
+        c.description = 'Authenticate with the Spotify API'
+        c.action do
+          spotify_username = ask('Your Spotify Username: ')
+          puts
+          puts 'Go to the link below to authorize Shellify.'
+          puts generate_oauth_url
+          oauth_credentials = Shellify::OauthCallbackHandler.run(@config)
+          @user.id = spotify_username
+          @user.token = oauth_credentials['access_token']
+          @user.refresh_token = oauth_credentials['refresh_token']
+          @user.save!
+        end
+      end
+
       command :devices do |c|
         c.description = 'List available playback devices'
         c.action do
@@ -48,14 +74,16 @@ module Shellify
       command :like do |c|
         c.description = 'Save the current song to your library'
         c.action do
-          @user.save_tracks!([@user.player.currently_playing])
+          exit_with_message(local_track_message, 0) if track_is_local?(playing)
+          @user.save_tracks!([playing])
         end
       end
 
       command :unlike do |c|
         c.description = 'Remove the current song from your library'
         c.action do
-          @user.remove_tracks!([@user.player.currently_playing])
+          exit_with_message(local_track_message, 0) if track_is_local?(playing)
+          @user.remove_tracks!([playing])
         end
       end
 
@@ -73,10 +101,12 @@ module Shellify
         c.action do |args, options|
           return puts "  Nothing playing" unless @user.player.playing?
 
+          exit_with_message(local_track_message, 0) if track_is_local?(playing)
           playlist = @user.playlists.find { |p| p.name == args[0] }
           return puts "  Playlist not found" unless playlist
+          exit_with_message(add_to_collaborative_playlist_message, 0) if playlist.owner != @user
 
-          playlist.add_tracks!([@user.player.currently_playing])
+          playlist.add_tracks!([playing])
         end
       end
 
@@ -85,10 +115,12 @@ module Shellify
         c.action do |args, options|
           return puts "  Nothing playing" unless @user.player.playing?
 
+          exit_with_message(local_track_message, 0) if track_is_local?(playing)
           playlist = @user.playlists.find { |p| p.name == args[0] }
           return puts "  Playlist not found" unless playlist
+          exit_with_message(add_to_collaborative_playlist_message, 0) if playlist.owner != @user
 
-          playlist.remove_tracks!([@user.player.currently_playing])
+          playlist.remove_tracks!([playing])
         end
       end
 
@@ -150,12 +182,29 @@ module Shellify
 
     private
 
+    def playing
+      @user.player.currently_playing
+    end
+
+    def local_track_message
+      "  Shellify can't perform this action for local tracks"
+    end
+
+    def add_to_collaborative_playlist_message
+      " Shellify can't perform this action for collaborative playlists you don't own"
+    end
+
+    def track_is_local?(track)
+      track.uri.split(':')[1] == 'local'
+    end
+
     def print_current_song
-      playing = @user.player.currently_playing
       puts '  Now Playing:'
       puts "  #{playing.name} - #{playing.artists.first.name} - "\
            "#{duration_to_s(@user.player.progress)}/#{duration_to_s(playing.duration_ms)}"\
-           "#{" - ♥" if @user.saved_tracks?([playing]).first}"
+           "#{" - ♥" if !track_is_local?(playing) && @user.saved_tracks?([playing]).first}"\
+           "#{" - local" if track_is_local?(playing)}"
+
     end
 
     def exit_with_message(message, code = 1)

data/lib/shellify/config.rb

@@ -2,37 +2,45 @@
 
 module Shellify
   class Config
-    attr_reader :client_id, :client_secret, :config_dir
+    attr_accessor :client_id, :client_secret, :config_dir
 
     CONFIG_DIR = ENV['HOME'] + '/.config/shellify'
     CONFIG_FILE = CONFIG_DIR + '/config.json'
+    SPOTIFY_AUTHORIZATION_SCOPES = %w[
+      user-read-playback-state
+      user-modify-playback-state
+      user-read-currently-playing
+      user-library-modify
+      user-library-read
+      playlist-modify-private
+      playlist-read-collaborative
+      playlist-read-private
+      playlist-modify-public
+    ].join(' ')
 
     def initialize
       @config_dir = CONFIG_DIR
       @config_file = CONFIG_FILE
-      create_config_file
       load_config
-      RSpotify.authenticate(@client_id, @client_secret)
+      RSpotify.authenticate(@client_id, @client_secret) if configured?
     end
 
-    private
+    def configured?
+      !@client_id.nil? && !@client_secret.nil?
+    end
 
-    def load_config
-      JSON.parse(File.read(CONFIG_FILE)).each_pair { |k,v| instance_variable_set("@#{k}", v) }
+    def save!
+      File.open(CONFIG_FILE, 'w') do |file|
+        file.write(JSON.pretty_generate({client_id: @client_id, client_secret: @client_secret}))
+      end
     end
 
-    def create_config_file
-      return if File.exists?(CONFIG_FILE)
+    private
 
-      FileUtils.mkdir_p(CONFIG_DIR)
-      FileUtils.touch(CONFIG_FILE)
-      write_default_config
-    end
+    def load_config
+      return unless File.exists?(CONFIG_FILE)
 
-    def write_default_config
-      File.open(CONFIG_FILE, 'w') do |file|
-      file.write(JSON.pretty_generate({client_id: '', client_secret: ''}))
-      end
+      JSON.parse(File.read(CONFIG_FILE)).each_pair { |k,v| instance_variable_set("@#{k}", v) }
     end
   end
 end

data/lib/shellify/oauth_callback_handler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'cgi'
+require 'base64'
+
+module Shellify
+  class OauthCallbackHandler
+    def self.run(...)
+      new(...).run
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run
+      @server = TCPServer.open(8888)
+      @client = @server.accept
+
+      path = @client.gets.split[1]
+      params = CGI.parse(path.split('?').last).transform_values(&:first)
+      body = 'Success! (You can close this now)'
+
+      begin
+        tokens = fetch_tokens(params['code'])
+      rescue RestClient::Exception => e
+        body = "Spotify didn't like that\n" + e.response
+      end
+
+      @client.puts headers(body.length)
+      @client.puts body
+      tokens
+    ensure
+      @client.close if @client
+      @server.close
+    end
+
+    private
+
+    def headers(content_length)
+      [
+        'HTTP/1.1 200 Ok',
+        "date: #{Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT")}",
+        'server: ruby',
+        "Content-Length: #{content_length}",
+        '',
+        '',
+      ].join("\r\n")
+    end
+
+    def fetch_tokens(code)
+      headers = {
+        'Authorization': "Basic " + Base64.strict_encode64("#{@config.client_id}:#{@config.client_secret}"),
+      }
+
+      params = {
+        client_id: @config.client_id,
+        scope: Shellify::Config::SPOTIFY_AUTHORIZATION_SCOPES,
+        redirect_uri: 'http://localhost:8888/callback',
+        grant_type: 'authorization_code',
+        code: code,
+      }
+
+      JSON.parse(RestClient.post("https://accounts.spotify.com/api/token", params, headers))
+    end
+  end
+end

data/lib/shellify/user.rb

@@ -2,48 +2,62 @@
 
 module Shellify
   class User < RSpotify::User
+    attr_accessor :token, :refresh_token, :id
 
     USER_FILE = '/spotify_user.json'
 
     def initialize(config_dir)
       @config_dir = config_dir
+      @user_file_path = config_dir + USER_FILE
       create_user_file
-      @spotify_user = load_persisted_user
+      write_default_user
+      load_persisted_user
       super({
         'credentials' => {
-          'token' => @spotify_user.token,
-          'refresh_token' => @spotify_user.refresh_token,
+          'token' => @token,
+          'refresh_token' => @refresh_token,
           'access_refresh_callback' => access_refresh_callback,
         },
-        'id' => @spotify_user.id,
+        'id' => @id,
       })
     end
 
-    private
+    def configured?
+      !@token.empty? && !@refresh_token.empty? && !@id.empty?
+    end
 
-    def load_persisted_user
-      OpenStruct.new(JSON.parse(File.read(@config_dir + USER_FILE)))
+    def save!
+      File.open(@user_file_path, 'w') do |file|
+        file.write(JSON.pretty_generate({id: @id, token: @token, refresh_token: @refresh_token}))
+      end
     end
 
-    def persist_user(access_token)
-      @spotify_user.token = access_token
+    private
 
-      File.open(@config_dir + USER_FILE, 'w') do |file|
-        file.write(JSON.pretty_generate(@spotify_user.to_h))
-      end
+    def load_persisted_user
+      JSON.parse(File.read(@user_file_path)).each_pair { |k,v| instance_variable_set("@#{k}", v) }
     end
 
     def access_refresh_callback
       Proc.new do |new_access_token, _token_lifetime|
-        persist_user(new_access_token)
+        @token = new_access_token
+        save!
       end
     end
 
     def create_user_file
-      return if File.exists?(@config_dir + USER_FILE)
+      return if File.exists?(@user_file_path)
+
+      FileUtils.mkdir_p(@config_dir)
+      FileUtils.touch(@user_file_path)
+    end
 
-      FileUtils.mkdir_p(CONFIG_DIR)
-      FileUtils.touch(@config_dir + USER_FILE)
+    def write_default_user
+      return unless File.zero?(@user_file_path)
+
+      File.open(@user_file_path, 'w') do |file|
+        file.write(JSON.pretty_generate({id: '', token: '', refresh_token: '',}))
+      end
     end
   end
 end

data/lib/shellify/utils.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'time'
+require 'uri'
 
 module Shellify
   module Utils
@@ -15,5 +16,16 @@ module Shellify
     def time_to_ms(time)
       time.split(':').map { |a| a.to_i }.inject(0) { |a, b| a * 60 + b} * 1000
     end
+
+    def generate_oauth_url
+      url_params = {
+        response_type: 'code',
+        client_id: @config.client_id,
+        scope: Shellify::Config::SPOTIFY_AUTHORIZATION_SCOPES,
+        redirect_uri: 'http://localhost:8888/callback',
+      }
+
+      "https://accounts.spotify.com/authorize?#{URI.encode_www_form(url_params)}"
+    end
   end
 end

data/lib/shellify/version.rb

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

data/lib/shellify.rb

@@ -6,7 +6,8 @@ require 'rspotify'
 require 'shellify/version'
 
 module Shellify
-  autoload :Cli,     'shellify/cli'
-  autoload :Config,  'shellify/config'
-  autoload :User,    'shellify/user'
+  autoload :Cli,                  'shellify/cli'
+  autoload :Config,               'shellify/config'
+  autoload :User,                 'shellify/user'
+  autoload :OauthCallbackHandler, 'shellify/oauth_callback_handler'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shellify
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Derek Povah
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-28 00:00:00.000000000 Z
+date: 2022-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -80,6 +80,7 @@ files:
 - lib/shellify.rb
 - lib/shellify/cli.rb
 - lib/shellify/config.rb
+- lib/shellify/oauth_callback_handler.rb
 - lib/shellify/user.rb
 - lib/shellify/utils.rb
 - lib/shellify/version.rb