grooveshark 0.1.1

data/lib/grooveshark.rb

@@ -0,0 +1,10 @@
+require 'digest'
+require 'json'
+require 'rest-client'
+
+require 'grooveshark/errors'
+require 'grooveshark/request'
+require 'grooveshark/client'
+require 'grooveshark/user'
+require 'grooveshark/playlist'
+require 'grooveshark/song'

data/lib/grooveshark/client.rb

@@ -0,0 +1,84 @@
+module Grooveshark
+  class Client
+    include Grooveshark::Request
+    
+    attr_accessor :session, :comm_token
+    attr_reader :user
+  
+    def initialize(session=nil)
+      @session = session || get_session
+      get_comm_token
+    end
+    
+    # Obtain new session from Grooveshark
+    def get_session
+      resp = RestClient.get('http://listen.grooveshark.com')
+      resp.headers[:set_cookie].to_s.scan(/PHPSESSID=([a-z\d]{32});/i).flatten.first
+    end
+    
+    # Get communication token
+    def get_comm_token
+      puts "Grooveshark::Client.get_comm_token"
+      @comm_token = nil # so that it doesn't send a token
+      @comm_token = request('getCommunicationToken', {:secretKey => Digest::MD5.hexdigest(@session)}, true)
+    end
+    
+    # Sign method
+    def create_token(method)
+      rnd = rand(256**3).to_s(16).rjust(6, '0')
+      plain = [method, @comm_token, 'quitStealinMahShit', rnd].join(':')
+      hash = Digest::SHA1.hexdigest(plain)
+      "#{rnd}#{hash}"
+    end
+    
+    # Authenticate user
+    def login(user, password)
+      data = request('authenticateUser', {:username => user, :password => password}, true)
+      @user = User.new(self, data)
+      raise InvalidAuthentication, 'Wrong username or password!' if @user.id == 0
+      return @user
+    end
+  
+    # Perform search request for query
+    def search(type, query)
+      results = request('getSearchResults', {:type => type, :query => query})
+      results.map { |song| Song.new song }
+    end
+    
+    # Perform songs search request for query
+    def search_songs(query)
+      search('Songs', query)
+    end
+    
+    # Return raw response for songs search request
+    def search_songs_pure(query)
+      request('getSearchResultsEx', {:type => 'Songs', :query => query})
+    end
+    
+    # Get stream authentication by song ID
+    def get_stream_auth_by_songid(song_id)
+      request('getStreamKeyFromSongIDEx', {
+        'songID'    => song_id,
+        'prefetch'  => false,
+        'mobile'    => false,
+        'country'   => COUNTRY
+      })
+    end
+  
+    # Get stream authentication for song object
+    def get_stream_auth(song)
+      get_stream_auth_by_songid(song.id)
+    end
+    
+    # Get song stream url by ID
+    def get_song_url_by_id(id)
+      resp = get_stream_auth_by_songid(id)
+      "http://#{resp['ip']}/stream.php?streamKey=#{resp['streamKey']}"
+    end
+    
+    # Get song stream
+    def get_song_url(song)
+      get_song_url_by_id(song.id)
+    end
+  end
+end

data/lib/grooveshark/errors.rb

@@ -0,0 +1,4 @@
+module Grooveshark
+  class InvalidAuthentication < Exception ; end
+  class GeneralError < Exception ; end
+end

data/lib/grooveshark/playlist.rb

@@ -0,0 +1,44 @@
+module Grooveshark
+  class Playlist
+    attr_reader :id, :user_id
+    attr_reader :name, :about, :picture, :username
+    attr_reader :songs
+    
+    def initialize(client, data=nil, user_id=nil)
+      @client = client
+      @songs = []
+    
+      if data
+        @id       = data['PlaylistID']
+        @name     = data['Name']
+        @about    = data['About']
+        @picture  = data['Picture']
+        @user_id  = data['UserID'] || user_id
+        @username = data['Username']
+      end
+    end
+
+    # Fetch playlist songs
+    def load_songs
+      @songs = @client.request('playlistGetSongs', :playlistID => @id)['Songs']
+      @songs.map! { |s| Song.new(s) }
+    end
+    
+    # Rename playlist
+    def rename(name, description)
+      begin
+        @client.request('renamePlaylist', :playlistID => @id, :playlistName => name)
+        @client.request('setPlaylistAbout', :playlistID => @id, :about => description)
+        @name = name ; @about = description
+        return true
+      rescue
+        return false
+      end
+    end
+    
+    # Delete existing playlist
+    def delete
+      @client.request('deletePlaylist', {:playlistID => @id, :name => @name})
+    end
+  end
+end

data/lib/grooveshark/request.rb

@@ -0,0 +1,46 @@
+module Grooveshark
+  module Request
+    API_BASE = 'cowbell.grooveshark.com'
+    UUID = 'E2AB1A59-C6B7-480E-992A-55DE1699D7F8'
+    CLIENT = 'htmlshark'
+    CLIENT_REV = '20101012.37'
+    COUNTRY = {"CC2" => "0","IPR" => "1","CC1" => "0","ID" => "1","CC4" => "0","CC3" => "0"}
+    
+    # Client overrides for different methods
+    METHOD_CLIENTS = {
+      'getStreamKeyFromSongIDEx' => 'jsqueue' 
+    }
+    
+    # Perform API request
+    def request(method, params, secure=false)
+      agent = METHOD_CLIENTS.key?(method) ? METHOD_CLIENTS[method] : CLIENT
+      url = "#{secure ? 'https' : 'http'}://#{API_BASE}/more.php?#{method}"
+      body = {
+        'header' => {
+          'session' => @session,
+          'uuid' => UUID,
+          'client' => agent,
+          'clientRevision' => CLIENT_REV,
+          'country' => COUNTRY
+        },
+        'method' => method,
+        'parameters' => params
+      }
+      body['header']['token'] = create_token(method) if @comm_token
+      
+      begin
+        data = RestClient.post(
+          url, body.to_json,
+          :content_type => :json,
+          :accept => :json,
+          :cookie => "PHPSESSID=#{@session}"
+        )
+      rescue Exception => ex
+        raise GeneralError    # Need define error handling
+      end
+      
+      data = JSON.parse(data)
+      return data['result'] unless data['fault']
+    end
+  end
+end

data/lib/grooveshark/song.rb

@@ -0,0 +1,40 @@
+module Grooveshark
+  class Song
+    attr_reader :data
+    attr_reader :id, :artist_id, :album_id
+    attr_reader :name, :artist, :album, :track
+    attr_reader :duraion, :artwork, :playcount
+  
+    def initialize(data=nil)
+      unless data.nil?
+        @data       = data
+        @id         = data['SongID']
+        @name       = data['SongName'] || data['Name']
+        @artist     = data['ArtistName']
+        @artist_id  = data['ArtistID']
+        @album      = data['AlbumName']
+        @album_id   = data['AlbumID']
+        @track      = data['TrackNum']
+        @duration   = data['EstimateDuration']
+        @artwork    = data['CoverArtFilename']
+        @playcount  = data['SongPlays']
+      end
+    end
+    
+    def to_s
+      [@id, @name, @artist].join(' - ')
+    end
+    
+    def to_hash
+      {
+        'songID'      => @id,
+        'songName'    => @name,
+        'artistName'  => @artist,
+        'artistID'    => @artist_id,
+        'albumName'   => @album,
+        'albumID'     => @album_id,
+        'track'       => @track
+      }
+    end
+  end
+end

data/lib/grooveshark/user.rb

@@ -0,0 +1,87 @@
+module Grooveshark
+  class User
+    attr_reader :id, :username, :premium, :data
+    attr_reader :playlists, :favorites
+
+    # Init user account object
+    def initialize(client, data=nil)
+      if data
+        @data = data
+        @id = data['userID']
+        @username = data['username']
+        @premium = data['isPremium']
+      end
+      @client = client
+    end
+    
+    # --------------------------------------------------------------------------
+    # User Library
+    # --------------------------------------------------------------------------
+    
+    # Fetch songs from library 
+    def library(page=0)
+      resp = @client.request('userGetSongsInLibrary', {:userID => @id, :page => page.to_s})['Songs']
+      resp.map { |s| Song.new(s) }
+    end
+    
+    # Add songs to user library (DOES NOT WORK FOR SOME REASON)
+    def library_add(songs=[])
+      @client.request('userAddSongsToLibrary', {:songs => songs.map { |s| s.to_hash }})
+    end
+    
+    # Remove song from user library
+    def library_remove(song)
+      song_id = song.kind_of?(Song) ? song.id : song.to_s
+      @client.request('userRemoveSongFromLibrary', {:userID => @id, :songID => song_id})
+    end
+    
+    # --------------------------------------------------------------------------
+    # User Playlists
+    # --------------------------------------------------------------------------
+    
+    # Fetch user playlists
+    def playlists
+      return @playlists if @playlists
+      results = @client.request('userGetPlaylists', :userID => @id)
+      @playlists = results['Playlists'].map { |list| Playlist.new(@client, list, @id) }
+    end
+    
+    # Get playlist by ID
+    def get_playlist(id)
+      result = playlists.select { |p| p.id == id }
+      result.nil? ? nil : result.first
+    end
+    
+    # Create new user playlist
+    def create_playlist(name, description='', songs=[])
+      @client.request('createPlaylist', {
+        'playlistName' => name,
+        'playlistAbout' => description,
+        'songIDs' => songs.map { |s| s.kind_of?(Song) ? s.id : s.to_s }
+      })
+    end
+    
+    # --------------------------------------------------------------------------
+    # User Favorites
+    # --------------------------------------------------------------------------
+    
+    # Get user favorites
+    def favorites
+      return @favorites if @favorites
+      resp = @client.request('getFavorites', :ofWhat => 'Songs', :userID => @id)
+      @favorites = resp.map { |s| Song.new(s) }
+    end
+    
+    # Add song to favorites
+    def add_favorite(song)
+      song_id = song.kind_of?(Song) ? song.id : song
+      @client.request('favorite', {:what => 'Song', :ID => song_id})
+    end
+    
+    # Remove song from favorites
+    def remove_favorite(song)
+      song_id = song.kind_of?(Song) ? song.id : song
+      @client.request('unfavorite', {:what => 'Song', :ID => song_id})
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: grooveshark
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Dan Sosedoff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-08 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :runtime
+  version_requirements: *id002
+description: Unofficial ruby library for consuming the Grooveshark API.
+email: dan.sosedoff@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/grooveshark.rb
+- lib/grooveshark/client.rb
+- lib/grooveshark/errors.rb
+- lib/grooveshark/playlist.rb
+- lib/grooveshark/request.rb
+- lib/grooveshark/song.rb
+- lib/grooveshark/user.rb
+has_rdoc: true
+homepage: http://github.com/sosedoff/grooveshark
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: Grooveshark API
+test_files: []
+