spotifiery 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spotifiery.sublime-project
+spotifiery.sublime-workspace

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spotifiery.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 cicloon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Spotifiery
+
+Spotifiery is a simple wrapper for the Spotify web API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'spotifiery'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spotifiery
+
+## Usage
+
+Using it is very simple:
+
+There are three "searchable items":
+
+- Track
+- Album
+- Artist
+
+To search for a track you can do:
+
+Spotifiery::Searchable::Track.find(:q => 'Stairway to Heaven')
+
+Which will return a SearchResult containing tracks called "Stairway to Heaven".
+
+It accepts the same params as the spotify API so if you want to look for the page 2 of search results you should do:
+
+Spotifiery::Searchable::Track.find(:q => 'Stairway to Heaven', :page => 2)
+
+A find will return a SearchResult object which contains metadata about the query performed like "num_results", "limit", "offset", "page"... and of course the result set, which can be accessed via the results method (if you've searched for tracks you can use the tracks method too, the same applies to albums or artists).
+
+A Searchable contains all the metadata about itself and allows navigation through the API, p.e.: you can ask a track about its artits or about its album. 
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/spotifiery/search_result/base.rb

@@ -0,0 +1,44 @@
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+
+module Spotifiery
+
+  module SearchResult
+
+    class Base
+      
+      def initialize response
+
+        response_hash = HashWithIndifferentAccess.new response        
+        
+        @info = response_hash[:info]
+        response_results = response_hash[ ActiveSupport::Inflector.pluralize(@info[:type]) ]
+        response_class = ActiveSupport::Inflector.constantize( "Spotifiery::Searchable::" + ActiveSupport::Inflector.titleize(@info[:type]))
+        @results = response_results.map{|result_hash| response_class.new(result_hash) }
+      end
+
+      def results
+        @results
+      end
+
+
+      def method_missing(method, *args, &block)                
+        if defined?(@info) && @info.has_key?(method)
+          @info[method]
+        elsif defined?(@info) && method.eql?( ActiveSupport::Inflector.pluralize(@info[:type]).to_sym )
+          @results
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @info.has_key?(method) || method.eql?(ActiveSupport::Inflector.pluralize(@info[:type]).to_sym)
+      end
+                        
+    end
+
+  end
+
+end 

data/lib/spotifiery/search_result.rb

@@ -0,0 +1,12 @@
+module Spotifiery
+
+  module SearchResult        
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    
+       
+  end
+
+
+end

data/lib/spotifiery/searchable/album.rb

@@ -0,0 +1,40 @@
+module Spotifiery
+
+  module Searchable
+
+    class Album
+      include Base                        
+      LOOKUPS = ['artist' , 'track']
+      QUERY_EXTRA_DEFAULT = 'trackdetail'
+
+      private
+
+      # Spotify messed it up with albums and artists.
+      # An Album lookup returns artist as artist-id: "spotify:artist:7jy3rLJdDQY21OgRLCZ9sD" and artist: "Foo Fighters"
+      # An Album search returns artists as [{href: "spotify:artist:7jy3rLJdDQY21OgRLCZ9sD",name: "Foo Fighters"}]
+      # This is fixed here
+      def lookup_in_spotify      
+        perform_lookup
+        parsed_response = @lookup_response.parsed_response
+        searchable_type = self.class.name.demodulize.downcase
+
+        # Build the artist hash as it is on search results
+        artist_hash = HashWithIndifferentAccess.new({ :name => parsed_response[searchable_type]['artist'], :href => parsed_response[searchable_type]['artist-id']})
+
+        # Remove artist references from lookup response
+        parsed_response[searchable_type].delete(:artist)
+        parsed_response[searchable_type].delete('artist-id')
+
+        # Set artists as it is on search results
+        parsed_response[searchable_type]['artists'] = [artist_hash]        
+
+        # Initialize attributes as always
+        set_base_attributes_by_lookup parsed_response
+      end
+
+
+    end
+
+  end
+
+end 

data/lib/spotifiery/searchable/artist.rb

@@ -0,0 +1,13 @@
+module Spotifiery
+
+  module Searchable
+
+    class Artist
+      include Base                        
+      LOOKUPS = ['album']
+      QUERY_EXTRA_DEFAULT = 'albumdetail'
+    end
+
+  end
+
+end 

data/lib/spotifiery/searchable/base.rb

@@ -0,0 +1,158 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/string'
+
+module Spotifiery
+
+  module Searchable
+
+    module Base
+
+      extend ActiveSupport::Concern
+      BASE_SEARCH_URL = "http://ws.spotify.com/search/1/"
+      BASE_LOOKUP_URL = "http://ws.spotify.com/lookup/1/.json"
+
+      
+      included do                 
+        include HTTParty        
+        base_uri BASE_SEARCH_URL
+        format :json        
+      end
+
+      module ClassMethods
+
+        # Search for something (track, album or artist).
+        # Accept the same params as spotify search API
+        def find opts = {}        
+          parsed_response = ask_spotify opts
+          Spotifiery::SearchResult::Base.new parsed_response
+        end
+
+        private
+
+        def ask_spotify opts = {}          
+          opts = {:q => '', :page => '1'}.merge opts
+          self.get("/#{name.demodulize.downcase}.json" , :query => opts.to_param ).parsed_response
+        end
+      end
+      
+
+      # Can be initialized from a spotify uri or from an search result hash.
+      # This way Spotify is not asked when initialized from a search result when name, popularity, etc are called
+      def initialize spotify_uri_or_hash
+              
+        if spotify_uri_or_hash.is_a? Hash          
+          initialize_base_attributes_getters HashWithIndifferentAccess.new spotify_uri_or_hash
+          @href = spotify_uri_or_hash['href']
+
+        elsif spotify_uri_or_hash.is_a? String          
+          
+          @href = spotify_uri_or_hash
+          
+        else
+          raise "Wrong initialize params"
+        end
+      end
+
+
+      private
+
+      def method_missing(method, *args, &block)
+        
+        # Looked in spotify before?
+        if !defined?(@lookup_response)
+          lookup_in_spotify
+        end
+
+        # Try to find the method in base_attributes
+        if @base_attributes.has_key? method
+          # Always try to parse for integers
+          Integer(@base_attributes[method],10) rescue @base_attributes[method]
+        # If not try to see if an instance variable is defined
+        elsif instance_variable_defined?("@#{method}")
+            instance_variable_get("@#{method}")
+        else
+          super
+        end
+
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if !defined? @lookup_response
+          lookup_in_spotify
+        end
+        @base_attributes.has_key?(method) || instance_variable_defined?("@#{method}")
+      end
+
+      # Perform a lookup, taking all the metadata from Spotify.
+      def lookup_in_spotify      
+        perform_lookup
+        parsed_response = HashWithIndifferentAccess.new @lookup_response.parsed_response              
+        set_base_attributes_by_lookup parsed_response
+      end
+
+      def perform_lookup
+        @lookup_response = HTTParty.get( Spotifiery::Searchable::Base::BASE_LOOKUP_URL, :query => {:uri => @href, :extras => self.class::QUERY_EXTRA_DEFAULT } )
+      end
+
+      # Define base attribute methods from an Spotify lookup
+      def set_base_attributes_by_lookup attributes_hash
+        searchable_type = self.class.name.demodulize.downcase      
+        initialize_base_attributes_getters attributes_hash[ searchable_type ]
+      end
+
+      # Define methods from a hash
+      def initialize_base_attributes_getters attributes_hash
+
+        @base_attributes ||= {}
+
+        attributes_hash.each do |key, value|   
+
+          attribute = key.underscore.to_sym                    
+          if !self.class::LOOKUPS.include? attribute.to_s.singularize
+
+            @base_attributes[ attribute ] = value             
+            define_base_method attribute if !defined? attribute
+
+          else
+            initialize_lookup attribute, value
+          end 
+        end
+      end
+
+      # Define methods that require new searchables
+      def initialize_lookup attribute, value
+        singular_attribute = attribute.to_s.singularize
+        searchable_class = ("Spotifiery::Searchable::" + singular_attribute.titleize ).constantize
+
+        searchable_instance = if value.is_a? Array          
+          value.map {|val| searchable_class.new val }
+        else
+          searchable_class.new value
+        end
+
+        instance_variable_set("@#{attribute}", searchable_instance)
+        define_searchable_method attribute        
+      end
+
+      def define_base_method method
+        send(:define_singleton_method, method) do
+          # Always try to parse for integers
+          Integer(@base_attributes[attribute],10) rescue @base_attributes[attribute]
+        end
+      end
+
+      def define_searchable_method method
+        send(:define_singleton_method, method) do
+          instance_variable_get("@#{method}")          
+        end
+      end
+
+
+    end
+
+    
+
+  end
+
+
+end

data/lib/spotifiery/searchable/track.rb

@@ -0,0 +1,13 @@
+module Spotifiery
+
+  module Searchable
+
+    class Track 
+      include Base
+      LOOKUPS = ['artist' , 'album']
+      QUERY_EXTRA_DEFAULT = nil                        
+    end
+
+  end
+
+end 

data/lib/spotifiery/searchable.rb

@@ -0,0 +1,14 @@
+module Spotifiery
+
+  module Searchable    
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Track
+    autoload :Album
+    autoload :Artist
+       
+  end
+
+
+end

data/lib/spotifiery/version.rb

@@ -0,0 +1,3 @@
+module Spotifiery
+  VERSION = "0.0.1"
+end

data/lib/spotifiery.rb

@@ -0,0 +1,13 @@
+ # encoding: utf-8
+
+require 'httparty'
+require 'active_support'
+
+module Spotifiery
+  extend ActiveSupport::Autoload
+
+  autoload :Searchable
+  autoload :SearchResult
+
+
+end