robut-rdio 0.1.0 → 0.1.2

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+### 0.2 / 2010-12-02
+
+#### Searching and Playing:
+
+* Defaults to searching for tracks
+* Ability to skip to next album
+* Added the ability to search by artist
+* Queuing songs from result set allows the specification of multiple songs
+
+#### Server page:
+
+* Shortcut keys to control playback
+* Images to describe state of connection and playback
+
+#### Notifications within Hipchat for when:
+
+* song starts playing
+* plugin has stopped playing
+* Rdio is being used elsewhere by a user
+
+#### Testing and Documentation
+
+* Added cucumber tests for integration
+* Added more unit tests
+* Better usage and installation instructions
+
+### 0.1 / 2011-11-10
+
+* Initial Release

data/Gemfile

@@ -3,16 +3,25 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-gem 'robut'
+gem 'robut', :git => 'git://github.com/substantial/robut.git', 
+  :ref => '37de65af7c42ea691f3e76e8952a5821b8170be0'
+
+gem 'rdio', '0.0.91' # .92 is horked
+gem 'sinatra'
+gem 'thin'
+
 group :development do
-  gem 'thin'
-  gem "rspec", "~> 2.3.0"
+  gem "rspec"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.4"
   gem "rcov", ">= 0"
-  gem 'rdio', '0.0.91' # .92 is horked
-  gem 'sinatra'
   gem 'highline'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'ruby-debug19', :require => 'ruby-debug'
+end
+
+group :test do
+  gem 'rack-test'
+
 end

data/Gemfile.lock

@@ -1,41 +1,68 @@
+GIT
+  remote: git://github.com/substantial/robut.git
+  revision: 37de65af7c42ea691f3e76e8952a5821b8170be0
+  ref: 37de65af7c42ea691f3e76e8952a5821b8170be0
+  specs:
+    robut (0.3.0)
+      xmpp4r (~> 0.5.0)
+
 GEM
   remote: http://rubygems.org/
   specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.5)
     daemons (1.1.4)
     diff-lcs (1.1.3)
     eventmachine (0.12.10)
     git (1.2.5)
-    highline (1.6.5)
+    guard (0.8.8)
+      thor (~> 0.14.6)
+    guard-rspec (0.5.8)
+      guard (>= 0.8.4)
+    highline (1.6.8)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
     oauth (0.4.5)
     rack (1.3.5)
     rack-protection (1.1.4)
       rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
     rake (0.9.2.2)
     rcov (0.9.11)
     rdio (0.0.91)
       oauth (>= 0.3.0)
-    robut (0.3.0)
-      xmpp4r (~> 0.5.0)
-    rspec (2.3.0)
-      rspec-core (~> 2.3.0)
-      rspec-expectations (~> 2.3.0)
-      rspec-mocks (~> 2.3.0)
-    rspec-core (2.3.1)
-    rspec-expectations (2.3.0)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.3.0)
+    rspec-mocks (2.7.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
     sinatra (1.3.1)
       rack (~> 1.3, >= 1.3.4)
       rack-protection (~> 1.1, >= 1.1.2)
       tilt (~> 1.3, >= 1.3.3)
-    thin (1.2.11)
+    thin (1.3.1)
       daemons (>= 1.0.9)
       eventmachine (>= 0.12.6)
       rack (>= 1.0.0)
+    thor (0.14.6)
     tilt (1.3.3)
     xmpp4r (0.5)
 
@@ -44,11 +71,15 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.0.0)
+  guard
+  guard-rspec
   highline
   jeweler (~> 1.6.4)
+  rack-test
   rcov
   rdio (= 0.0.91)
-  robut
-  rspec (~> 2.3.0)
+  robut!
+  rspec
+  ruby-debug19
   sinatra
   thin

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => "--color --format d"  do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/support/.+\.rb$})  { "spec" }
+end
+

data/README.md

@@ -1,12 +1,126 @@
-robut-rdio
-====================
+# robut-rdio
 
-A web-powered RDIO plugin for robut
+Robut-rdio gives the ability for individuals within a [Hipchat](http://www.hipchat.com) chat room to enqueue, play, and manage songs through a web-based [rdio](http://www.rdio.com/) page. Robut-rdio is a plugin for [robut](https://github.com/justinweiss/robut).
 
-How to test Robut-Rdio interactively
-------------------
+## Usage 
 
-You can test the plugin in an interative shell with:
+### Controls
+
+* `find <ARTIST, ALBUM, TRACK>` - searches for the given term and returns a result set
+* `play <INDEX>` - play the track with the given index in the result set
+* `pause` - pause the current playing song
+* `unpause` or `play` - will resume playing the current track
+* `next` will move to the next avaiable track
+* `back` will move to the previous track
+* `restart` will restart the current track over at the beginning
+* `clear` will remove all the currently enqueued songs
+
+#### `find` and `play`
+
+As a user within a Hipchat channel, you will likely spend your time searching for and queuing music.
+
+```
+@dj find <Track>
+```
+
+A list of matching results will be returned and presented in the chat room.
+
+```
+<Index>: <Artist> - <Album> - <Track>
+```
+
+* You can enqueue one of the results by simply referencing the index number.
+* Any user can make a selection from the results that are returned.
+* Making new requests of robut will replace any previously specified indexes.
+
+
+##### Search By Album
+
+```
+@dj find album <Album>
+```
+
+##### Search By Artist
+
+```
+@dj find artist <Artist>
+```
+
+##### Example
+
+```
+user > @dj find Beck - Guero
+
+dj   > Searching for: guero...
+0: Beck - Guero
+1: Beck - Guero - E-Pro
+2: Beck - Guero - Girl
+3: Beck - Guero - Que' Onda Guero
+4: Beck - Guero - Black Tambourine
+5: Beck - Guero - Missing
+6: Beck - Guero - Hell Yes
+7: Beck - Guero - Earthquake Weather
+8: Beck - Guero - Go It Alone
+9: Beck - Guero - Broken Drum
+
+user > @dj play 0
+```
+
+### Web 
+
+Along with the bot within the hipchat channel to provide you with feedback information, the webpage playing the music also provides information about the state of the current track and playlist. Most of the images used are standard images to represent: play; paused; and stopped. There are two other states that are important to note:
+
+![Buffering](https://github.com/radamant/robut-rdio/raw/event-reporting/lib/server/public/images/buffering.png) This appears when a track is first loaded and the audio data is being loaded for playback.
+
+![Disconnected](https://github.com/radamant/robut-rdio/raw/event-reporting/lib/server/public/images/disconnected.png) This appears when the current Rdio account is being used in another location. This will prevent all playback.
+
+
+### Web Controls
+
+The webpage itself allows for keyboard input. This allows for the system running the webpage to expose the ability to control the music similar to individuals within the chatroom. This has been tested with [Remote Buddy](http://www.iospirit.com/products/remotebuddy/) with custom keys mapped to the remote's buttons.
+
+* `space` to toggle playing and pausing the current playing track
+* `<-` or `p` to restart the current track or twice to move to the previous track
+* `->` or `n` to move to the next track
+
+## Installation
+
+### Requirements
+
+* [Robut](https://github.com/justinweiss/robut)
+* [Rdio API](http://developer.rdio.com/) (Key & Secret)
+
+### Robut Chatfile
+
+```ruby
+# Require the plugin into your chat file
+require 'robut-rdio'
+
+# Specify your RDIO_KEY and RDIO_SECRET
+Robut::Plugin::Rdio.key = "RDIO_KEY"
+Robut::Plugin::Rdio.secret = "RDIO_SECRET"
+
+# Start the Sinatra Server required to stream the music from Rdio
+Robut::Plugin::Rdio.start_server
+
+# Add the plugin to the list of available plugins
+Robut::Plugin.plugins << Robut::Plugin::Rdio
+
+# ... other robut configuration information ...
+```
+
+
+## Development
+
+### Robut-Rdio without Hipchat
+
+Robut-Rdio comes with an interactive shell mode that makes it wasy to interact with the Rdio service. This functionaliy allows you to interact with the plugin without the requirement of Hipchat.
+
+### Start the interactive shell
+
+* Clone the repository
+
+* Execute the following command:
 
 ```shell
 export RDIO_KEY=<your key>
@@ -14,9 +128,7 @@ export RDIO_SECRET=<your secret>
 rake shell
 ```
 
-This will open a pseudo-robut environment where anything entered into the shell will be responded to as if it were a hipchat message.
-
-You shoule see something like:
+* Visit the server and port specified in start up:
 
 ```shell
 == Sinatra/1.3.1 has taken the stage on 4567 for development with backup from Thin
@@ -24,20 +136,13 @@ You shoule see something like:
 >> Maximum connections set to 1024
 >> Listening on 0.0.0.0:4567, CTRL+C to stop
 Welcome to the robut plugin test environment.
-
-You can direct your messages to the bot using:
-@dj
-
-Type 'exit' or 'quit' to exit this session
-
-hipchat> 
-
 ```
 
-You can now point a web browser to the url that Rack gives you to run the client as well while you test the chat input.
+By default the server will start at [localhost:4567](http://localhost:4567). It is important that the page is open to allow requests that are made to be added to the queue maintained by the Rdio object within the page.
 
+* Make requests to the DJ within the interactive shell:
 
-Then you can do the following while your web browser responds to the changes:
+You can make any requests that you would normally make within a Hipchat channel. The bot will read and respond to requests prefaced with the username `@dj`.
 
 ```shell
 hipchat> @dj find guero

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/lib/robut-rdio.rb

@@ -45,6 +45,17 @@ class Robut::Plugin::Rdio
     Server.token = self.token || "GAlNi78J_____zlyYWs5ZG02N2pkaHlhcWsyOWJtYjkyN2xvY2FsaG9zdEbwl7EHvbylWSWFWYMZwfc="
     Server.domain = self.domain || "localhost"
   end
+  
+  #
+  # Because an instance of this plugin is not created until the Robut client has
+  # recieved at least one message. The server callbacks need to be created during
+  # the #handle request. This allows for the server to communicate back through
+  # the Robut communication channel that it receives the messages.
+  # 
+  def establish_server_callbacks!
+    Server.reply_callback ||= lambda{|message| reply(message, :room)}
+    Server.state_callback ||= lambda{|message| reply("/me #{message}", :room)}
+  end
 
   # Returns a description of how to use this plugin
   def usage
@@ -54,45 +65,158 @@ class Robut::Plugin::Rdio
       "#{at_nick} play track <track> - queues <track> for playing",
       "#{at_nick} play/unpause - unpauses the track that is currently playing",
       "#{at_nick} next - move to the next track",
+      "#{at_nick} next|skip album - skip all tracks in the current album group",
       "#{at_nick} restart - restart the current track"
     ]
   end
+ 
+  
+  #
+  # @param [String,Array] request that is being evaluated as a play request
+  # @return [Boolean]
+  #
+  def play_results_regex
+    /^(?:play)?\s?(?:result)?\s?((?:\d[\s,-]*)+|all)$/
+  end
+  
+  #
+  # @param [String,Array] request that is being evaluated as a play request
+  # @return [Boolean]
+  #
+  def play?(request)
+    Array(request).join(' ') =~ play_results_regex
+  end
+
+  #
+  # @param [Array,String] track_request the play request that is going to be 
+  #   parsed for available tracks.
+  # 
+  # @return [Array] track numbers that were identified.
+  # 
+  # @example Requesting multiple tracks
+  # 
+  #     "play 1"
+  #     "play 1 2"
+  #     "play 1,2"
+  #     "play 1-3"
+  #     "play 1, 2 4-6"
+  #     "play all"
+  #
+  def parse_tracks_to_play(track_request)
+    if Array(track_request).join(' ') =~ /play all/
+      [ 'all' ]
+    else
+      Array(track_request).join(' ')[play_results_regex,-1].to_s.split(/(?:\s|,\s?)/).map do |track| 
+        tracks = track.split("-")
+        (tracks.first.to_i..tracks.last.to_i).to_a
+      end.flatten
+    end
+  end
+
+  #
+  # @return [Regex] that is used to match searches for their parameters
+  # @see http://rubular.com/?regex=(find%7Cdo%20you%20have(%5Csany)%3F)%5Cs%3F(.%2B%5B%5E%3F%5D)%5C%3F%3F
+  # 
+  def search_regex
+    /(find|do you have(\sany)?)\s?(.+[^?])\??/
+  end
+  
+  #
+  # @param [String,Array] request that is being evaluated as a search request
+  # @return [Boolean]
+  #
+  def search?(request)
+    Array(request).join(' ') =~ search_regex
+  end
+
+  #
+  # @param [String,Array] request that is being evaluated as a search and playback 
+  #   request
+  # @return [Boolean]
+  #
+  def search_and_play?(request)
+    Array(request).join(' ') =~ /^play\b[^\b]+/
+  end
+
+  #
+  # @param [String,Array] request that is being evaluated as a command request
+  # @return [Boolean]
+  #
+  def command?(request)
+    Array(request).join(' ') =~ /^(?:play|(?:un)?pause|next|restart|back|clear)$/
+  end
 
+  #
+  # @param [String,Array] request that is being evaluated as a skip album request
+  # @return [Boolean]
+  #
+  def skip_album?(message)
+    message =~ /(next|skip) album/
+  end
+  
   # Queues songs into the Rdio web player. @nick play search query
   # will queue the first search result matching 'search query' into
   # the web player. It can be an artist, album, or song.
   def handle(time, sender_nick, message)
-    ::Rdio.init(self.class.key, self.class.secret)
+    
+    establish_server_callbacks!
+    
     words = words(message)
     
     if sent_to_me?(message)
-      if words.join(' ') =~ /^(play)?\s?(result)?\s?\d/
-        play_result(words.last.to_i)
-      elsif words.first == 'play' and words.length > 1
-        results = search(words)
-        result = results.first
-        if result
-          queue(result)
-        else
-          reply("I couldn't find #{words.join(" ")} on Rdio.")
+
+      if play?(words)
+
+        play_result *parse_tracks_to_play(words)
+        
+      elsif search_and_play?(words)
+        
+        search_and_play_criteria = words[1..-1].join(" ")
+        
+        unless search_and_play_result search_and_play_criteria
+          reply("I couldn't find '#{search_and_play_criteria}' on Rdio.")
         end
-      elsif words.join(' ') =~ /(find|do you have(\sany)?)\s?(.+[^?])\??/ 
-        find(['',Regexp.last_match[-1]])
-      else words.first =~ /play|(?:un)?pause|next|restart|back|clear/
-        run_command(words.first)
+        
+      elsif search?(words)
+        
+        find words.join(' ')[search_regex,-1]
+      
+      elsif skip_album?(message)
+
+        run_command("next_album")
+
+      else command?(words)
+        
+        run_command(words.join("_"))
+        
       end
       
     end
+    
   end
 
+  #
+  # As the plugin is initialized each time a request is made, the plugin maintains
+  # the state of the results from the last search request to ensure that it will
+  # be available when someone makes another request.
+  # 
   def results
     @@results
   end
-
+  
+  
   private
   RESULT_DISPLAYER = {
-    ::Rdio::Album => lambda{|album| "#{album.artist.name} - #{album.name}"},
-    ::Rdio::Track => lambda{|track| "#{track.artist.name} - #{track.album.name} - #{track.name}"}
+    ::Rdio::Album => lambda{|album| "#{album.artist_name} - #{album.name}"},
+    ::Rdio::Track => lambda{|track| "#{track.artist_name} - #{track.album_name} - #{track.name}"},
+    ::Rdio::Artist => lambda do |artist| 
+      tracks = artist.tracks(nil,0,1)
+      unless tracks.empty?
+        "#{artist.name} - #{tracks.first.album_name} - #{tracks.first.name}"
+      else
+        "#{artist.name}"
+      end
+    end
   }
 
   def run_command(command)
@@ -100,7 +224,7 @@ class Robut::Plugin::Rdio
   end
 
   def find(query)
-    reply("Searching for: #{query[1..-1].join(' ')}...")
+    reply("Searching for: #{query}...")
     @@results = search(query)
 
     result_display = format_results(@@results)
@@ -115,16 +239,40 @@ class Robut::Plugin::Rdio
     result_display
   end
 
-  def play_result(number)
+  def play_result(*requests)
+    
     if !has_results?
       reply("I don't have any search results") and return
     end
-
-    if !has_result?(number)
-      reply("I don't have that result") and return
+    
+    requests = requests.flatten.compact
+    
+    # Queue all the songs when the request is 'all'
+    
+    if requests.first == "all"
+      results.length.times {|index| queue result_at(index) }
+      return
     end
-
-    queue result_at(number)
+    
+    requests.flatten.each do |request|
+      
+      if has_result?(request.to_i)
+        queue result_at(request.to_i)
+      else
+        reply("I don't have that result")
+      end
+      
+    end
+    
+  end
+  
+  def search_and_play_result(message)
+    
+    if result = Array(search(message)).first
+      queue(result)
+      true
+    end
+    
   end
 
   def has_results?
@@ -153,21 +301,30 @@ class Robut::Plugin::Rdio
     "#{index}: #{response}"
   end
 
-  # Searches Rdio for sources matching +words+. If the first word is
-  # 'track', it only searches tracks, same for 'album'. Otherwise,
-  # matches both albums and tracks.
+  # Searches Rdio for sources matching +words+. 
+  # 
+  # Given an array of Strings, which are the search terms, use Rdio to find any
+  # tracks that match. If the first word happens be `album` then search for
+  # albums that match the criteria.
+  #
+  #
   def search(words)
+    ::Rdio.init(self.class.key, self.class.secret)
     api = ::Rdio::Api.new(self.class.key, self.class.secret)
-
-    if words[1] == "album"
-      query_string = words[2..-1].join(' ')
+    words = words.split(' ')
+    
+    if words.first == "album"
+      query_string = words[1..-1].join(' ')
       results = api.search(query_string, "Album")
-    elsif words[1] == "track"
-      query_string = words[2..-1].join(' ')
+    elsif words.first == "track"
+      query_string = words[1..-1].join(' ')
       results = api.search(query_string, "Track")
-    else
+    elsif words.first == "artist"
       query_string = words[1..-1].join(' ')
-      results = api.search(query_string, "Album,Track")
+      results = api.search(query_string, "Artist")
+    else
+      query_string = words.join(' ')
+      results = api.search(query_string, "Track")
     end
   end