spot 0.1.4 → 2.0.0

data/README.markdown

@@ -10,95 +10,69 @@ Follow me on [Twitter](http://twitter.com/linusoleander) for more info and updat
 
 ### Find a song
 
-The `Spot.find_song` method returns the first hit.
+The `Spot::Search.find_song` method returns the first hit.
 
 ```` ruby
-Spot.find_song("Like Glue")
+Spot::Search.find_song("Like Glue")
 ````
 
 ### Find all songs
 
-The `find_all_songs` method returns a list of `Song` objects.
+The `find_all_songs` method returns a list of `Spot::Song` objects.
 
 ```` ruby
-Spot.find_all_songs("Like Glue")
+Spot::Search.find_all_songs("Like Glue")
 ````
 
 ### Find an artist
 
-The `Spot.find_artist` method returns the first hit.
+The `Spot::Search.find_artist` method returns the first hit.
 
 ```` ruby
-Spot.find_artist("Madonna")
+Spot::Search.find_artist("Madonna")
 ````
 
 ### Find all artists
 
-The `find_all_artists` method returns a list of `Artist` objects.
+The `find_all_artists` method returns a list of `Spot::Artist` objects.
 
 ```` ruby
-Spot.find_all_artists("Madonna")
+Spot::Search.find_all_artists("Madonna")
 ````
 
 ### Find an album
 
-The `Spot.find_album` method returns the first hit.
+The `Spot::Search.find_album` method returns the first hit.
 
 ```` ruby
-Spot.find_album("Old Skool Of Rock")
+Spot::Search.find_album("Old Skool Of Rock")
 ````
 
 ### Find all albums
 
-The `find_all_albums` method returns a list of `Album` objects.
+The `find_all_albums` method returns a list of `Spot::Album` objects.
 
 ```` ruby
-Spot.find_all_albums("Old Skool Of Rock")
+Spot::Search.find_all_albums("Old Skool Of Rock")
 ````
 
 ### Find best match
 
-The `prime` method makes it possible to fetch the best matching result based on the ingoing argument.
+The `prime` method makes it possible to fetch the best matching result based on the ingoing argument. It will reject data (songs, artists and albums) that contains any of the [these words](https://github.com/oleander/Spot/blob/master/lib/spot/ignore.yml).
 
-Here is what is being returned *without* the `prime` method.
- 
-    >> Spot.find_song("sweet home").result
-    => Home Sweet Home - Mötley Crüe
-
-Here is what is being returned *with* the `prime` method.
-    
-    >> Spot.prime.find_song("sweet home").result
-    => Sweet Home Alabama - Lynyrd Skynyrd
-
-The `prime` method will reject data (songs, artists and albums) that contains any of the [these words](https://github.com/oleander/Spot/blob/master/lib/spot/exclude.yml).
-
-Here is the short version.
-
-- tribute
-- cover
-- remix
-- live
-- club mix
-- karaoke
-- remaster
-- club version
-- demo
-- made famous by
-- remixes
-- instrumental
-- ringtone
-
-Take a look at the [source code](https://github.com/oleander/Spot/blob/master/lib/spot.rb#L94) for more information.
+``` ruby
+Spot::Search.prime.find_song("Sweet Home Alabama")
+```
 
 ### Specify a territory
 
-All songs in Spotify isn't available everywhere.  
-Therefore it might be usefull to specify a location, also know as a *territory*.
+All songs in Spotify isn't available everywhere.
+It might therefore be usefull to specify a location, also know as a *territory*.
 
 If you for example want to find all songs available in Sweden, then you might do something like this.
 
 ```` ruby
-Spot.territory("SE").find_song("Sweet Home Alabama")
+Spot::Search.territory("SE").find_song("Sweet Home Alabama")
 ````
 
 You can find the complete territory list [here](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
@@ -109,97 +83,89 @@ Sometimes it may be useful to filer ingoing params.
 You can filter the ingoing string by using the `strip` method.
 
 ```` ruby
-Spot.strip.find_song("3. Who's That Chick ? feat.Rihanna [Singel Version] - (Single)")
+Spot::Search.strip.find_song("3. Who's That Chick ? feat.Rihanna [Singel Version] - (Single)")
 ````
 
 This is the string that is being passed to Spot.
 
     "who's that chick ?"
 
-Take a look at the [source code](https://github.com/oleander/Spot/blob/master/lib/spot.rb#L136) if you want to know what regexp is being used.
-
 ### Specify a page
 
-You can easily select any page you want by defining the `page` method.
-
 ```` ruby
-Spot.page(11).find_song("sweet home")
+Spot::Search.page(11).find_song("sweet home")
 ````
 
-The default page is of course `1`. :)
-
 ### Combine methods
 
-You can easily combine method like this.
+You can easily chain method like this.
 
 ```` ruby
-Spot.page(11).territory("SE").prime.strip.find_song("sweet home")
+Spot::Search.page(11).territory("SE").prime.strip.find_song("sweet home")
 ````
 
 ## Data to work with
 
 As soon as the `result` or `results` method is applied to the query a request to Spotify is made.
 
-Here is an example using the `result` method.
+Here is an example (`#result`).
 
-    >> song = Spot.find_song("sweet home").result
+    >> song = Spot::Search.find_song("sweet home").result
     
     >> puts song.title
     => Home Sweet Home
     
     >> puts song.class
-    => SpotContainer::Song
+    => Spot::Song
  
-Here is an example using the `results` method.
+Here is an example (`#results`).
    
-    >> songs = Spot.find_all_songs("sweet home").results
+    >> songs = Spot::Search.find_all_songs("sweet home").results
     >> puts songs.count
     => 100
 
 ### Base
 
-All classes, `Song`, `Artist` and `Album` share these methods.
+`Spot::Song`, `Spot::Artist` and `Spot::Album` shares the following methods.
 
 - **popularity** (*Float*) Popularity acording to Spotify. From `0.0` to `1.0`.
 - **href** (*String*) Url for the specific object.
 Default is a spotify url on this format: `spotify:track:5DhDGwNXRPHsMApbtVKvFb`.
-`http` may be passed as a string, which will return an Spotify HTTP Url on this format: `http://open.spotify.com/track/5DhDGwNXRPHsMApbtVKvFb`.
+`http` may be passed as a string, which will return an Spotify HTTP Url.
 - **available?** (*Boolean*) Takes one argument, a territory. Returns true if the object is accessible in the given region.
 Read more about it in the *Specify a territory* section above.
 - **to_s** (*String*) A string representation of the object.
 - **valid?** (*Boolean*) Returns true if the object is valid, a.k.a is accessible in the given territory. 
 If no territory is given, this will be true.
-- **name** (*String*) Name of the `Song`, `Artist` or `Album`. This method will return the same thing as `Song#title`.
+- **name** (*String*) Same as `Spot::Song#title`.
 
 ### Song
 
-Methods available for the `Song` class.
+Methods available for the `Spot::Song` class.
 
 - **length** (*Fixnum*) Length in seconds.
 - **title** (*String*) Song title.
-- **to_s** (*String*) String representation of the object in this format: *song - artist*.
+- **to_s** (*String*) String representation of the object in this format: *artist - song*.
 - **artist** (*Artist*) The artist.
 - **album** (*Album*) The album.
 
 ### Artist
 
-Methods available for the `Artist` class.
+Methods available for the `Spot::Artist` class.
 
 - **name** (*String*) Name of the artist.
 - **to_s** (*String*) Same as above.
 
 ### Album
 
-Methods available for the `Album` class.
+Methods available for the `Spot::Album` class.
     
 - **artist** (*Artist*) The artist.
 
 ### Spot
 
-This one is easier to explain in plain code.
-
 ```` ruby
-spot = Spot.find_song("kaizers orchestra")
+spot = Spot::Search.find_song("kaizers orchestra")
 
 puts spot.num_results # => 188
 puts spot.limit       # => 100
@@ -209,8 +175,8 @@ puts spot.query       # => "kaizers orchestra"
 
 - **num_results** (*Fixnum*) The amount of hits.
 - **limit** (*Fixnum*) The amount of results on each page.
-- **offset** (*Fixnum*) Unknown.
 - **query** (*String*) The search param that was passed to Spotify.
+- **offset** (*Fixnum*)
 
 ## Request limit!
 
@@ -218,8 +184,8 @@ puts spot.query       # => "kaizers orchestra"
 Which means that you can't just use it like this.
 
 ```` ruby
-["song1", "song2" ... ].each do |song|
-  Spot.find_song(song)
+["song1", "song2", ...].each do |song|
+  Spot::Search.find_song(song)
   # Do something with the data.
 end
 ````
@@ -234,7 +200,7 @@ require "spot"
 wires = []
 ["song1", "song2" ... ].each do |s|
   wires << Wire.new(max: 10, wait: 1, vars: [s]) do |song|
-    Spot.find_song(song)
+    Spot::Search.find_song(song)
     # Do something with the data.
   end
 end
@@ -248,7 +214,7 @@ wires.map(&:join)
 
 ## Requirements
 
-*Spot* is tested in *OS X 10.6.7* using Ruby *1.8.7*, *1.9.2*.
+*Spot* is tested in *OS X 10.6.7, 10.7.4* using Ruby *1.8.7*, *1.9.2*.
 
 ## License
 

data/lib/spot.rb

@@ -2,214 +2,209 @@
 require "spot/song"
 require "spot/artist"
 require "spot/album"
-require "json/pure"
+require "spot/clean"
+require "json"
 require "rest-client"
-require "uri"
 require "levenshteinish"
-require "rchardet19"
-require "iconv"
+require "charlock_holmes/string"
 require "yaml"
+require "uri"
 
-class Spot
-  def initialize
-    @methods = {
-      :artists => {
-        :selector => :artists,
-        :class    => SpotContainer::Artist,
-        :url      => generate_url("artist")
-      }, 
-      :songs => {
-        :selector => :tracks,
-        :class    => SpotContainer::Song,
-        :url      => generate_url("track")
-      },
-      :albums => {
-        :selector => :albums,
-        :class    => SpotContainer::Album,
-        :url      => generate_url("album")
+module Spot
+  class Search
+    def initialize
+      @methods = {
+        :artists => {
+          :selector => :artists,
+          :class    => Spot::Artist,
+          :url      => generate_url("artist")
+        }, 
+        :songs => {
+          :selector => :tracks,
+          :class    => Spot::Song,
+          :url      => generate_url("track")
+        },
+        :albums => {
+          :selector => :albums,
+          :class    => Spot::Album,
+          :url      => generate_url("album")
+        }
       }
-    }
-    
-    @cache = {}
-    
-    @exclude = YAML.load(File.read("#{File.dirname(__FILE__)}/spot/exclude.yml"))
-    
-    @config = {
-      :exclude    => 2,
-      :popularity => 7,
-      :limit      => 0.7,
-      :offset     => 10
-    }
+      
+      @cache = {}
+      
+      @exclude = YAML.load(File.read("#{File.dirname(__FILE__)}/spot/ignore.yml"))
+      
+      @config = {
+        :exclude    => 2,
+        :popularity => 7,
+        :limit      => 0.7,
+        :offset     => 10
+      }
+      
+      @options = {}
+    end
     
-    @options = {}
-  end
-  
-  def self.method_missing(method, *args, &blk)
-    Spot.new.send(method, *args, &blk)
-  end
-  
-  def method_missing(method, *args, &blk)
-    if method.to_s =~ /^find(_all)?_([a-z]+)$/i 
-      find($2, !!$1, args.first)
-    elsif scrape and content["info"].keys.include?(method.to_s)
-       content["info"][method.to_s]
-    else
-      super(method, *args, &blk)
+    def self.method_missing(method, *args, &blk)
+      Spot::Search.new.send(method, *args, &blk)
     end
-  end
-  
-  def page(value)
-    tap { @page = value }
-  end
-  
-  def prime
-    tap { @prime = true }
-  end
-  
-  def prefix(value)
-    tap { @prefix = value }
-  end
-  
-  def find(type, all, s)
-    tap {
-      @search = s
-      @type = all ? type.to_sym : "#{type}s".to_sym
-      raise NoMethodError.new(@type) unless @methods.keys.include?(@type)
-    }
-  end
-  
-  def results
-    @_results ||= scrape
-  end
-  
-  def strip
-    tap { @strip = true }
-  end
-  
-  def territory(value)
-    tap { @options.merge!(:territory => value) }
-  end
-  
-  def result
-    @prime ? results.sort_by do |res|
-      res.popularity
-    end.reverse[0..4].map do |r|
-      song, artist = type_of(r)
-      
-      match = "#{song} #{artist}".split(" ")
-      raw = clean!(search).split(" ")
-
-      if raw.length < match.length
-        diff = match - raw
-        res = diff.length.to_f/match.length
+    
+    def method_missing(method, *args, &blk)
+      if method.to_s =~ /^find(_all)?_([a-z]+)$/i 
+        find($2, !!$1, args.first)
+      elsif scrape and content["info"].keys.include?(method.to_s)
+         content["info"][method.to_s]
       else
-        diff = raw - match
-        res = diff.length.to_f/raw.length
+        super(method, *args, &blk)
       end
-
-      if diff.length > 1 and not match.map{ |m| diff.include?(m) }.all?
-        res =+ diff.map do |value|
-          match.map do |m|
-            Levenshtein.distance(value, m)
-          end.inject(:+)
-        end.inject(:+) / @config[:offset]
-      end
-      
-      [res - r.popularity/@config[:popularity], r]
-    end.reject do |distance, value|
-      exclude?(value.to_s) or not value.valid?
-    end.sort_by do |distance, _|
-      distance
-    end.map(&:last).first : results.first
-  end
-  
-  def type_of(r)
-    if @type == :songs
-      return r.name.to_s.downcase, r.artist.name.to_s.downcase
-    elsif @type == :artists
-      return r.song.title.to_s.downcase, r.name.to_s.downcase
-    else
-      return "", r.artist.to_s.downcase
     end
-  end
-  
-  def clean!(string)
-    string.strip!
     
-    # Song - A + B + C => Song - A
-    # Song - A abc/def => Song - A abc
-    # Song - A & abc def => Song - A
-    # Song - A "abc def" => Song - A
-    # Song - A [B + C] => Song - A
-    # Song A B.mp3 => Song A B
-    # Song a.b.c.d.e => Song a b c d e
-    # 10. Song => Song
-    [/\.[a-z0-9]{2,3}$/, /\[[^\]]*\]/,/".*"/, /'.*'/, /[&|\/|\+][^\z]*/, /^(\d+.*?[^a-z]+?)/i].each do |reg|
-      string = string.gsub(reg, '').strip
+    def page(value)
+      tap { @page = value }
     end
     
-    [/\(.+?\)/m, /feat(.*?)\s*[^\s]+/i, /[-]+/, /[\s]+/m, /\./, /\_/].each do |reg|
-       string = string.gsub(reg, ' ').strip
+    def prime
+      tap { @prime = true }
     end
     
-    {"ä" => "a", "å" => "a", "ö" => "o"}.each do |from, to|
-      string.gsub!(/#{from}/i, to)
+    def prefix(value)
+      tap { @prefix = value }
     end
     
-    string.gsub(/\A\s|\s\z/, '').gsub(/\s+/, ' ').strip.downcase
-  rescue Encoding::CompatibilityError
-    return string
-  end
-  
-  def exclude?(compare)
-    @exclude.map { |value| !! compare.match(/#{value}/i) }.any?
-  end
-  
-  private
-    def url
-      @url ||= @methods[@type][:url].
-        gsub(/<SEARCH>/, URI.escape(search)).
-        gsub(/<PAGE>/, (@page || 1).to_s)
+    def find(type, all, s)
+      tap {
+        @search = s
+        @type = all ? type.to_sym : "#{type}s".to_sym
+        raise NoMethodError.new(@type) unless @methods.keys.include?(@type)
+      }
     end
     
-    def search(force = false)
-      return @_search if @_search
-      @_search = ""
-      @_search = ((@strip or force) ? clean!(@prefix) + " " : @prefix + " ") if @prefix
-      @_search += ((@strip or force) ? clean!(@search) : @search)
+    def results
+      unless @prime
+        @_results ||= scrape.select(&:valid?)
+      else
+        @_results ||= scrape
+      end
     end
     
-    def scrape
-      return @cache[@type] if @cache[@type]
-      
-      @cache[@type] = []; content[@methods[@type][:selector].to_s].each do |item|
-        item = @methods[@type][:class].new(item.merge(@options)) 
-        @cache[@type] << item if item.valid? or @prime
-      end
-      @cache[@type]
+    def strip
+      tap { @strip = true }
     end
     
-    def content
-      data = download
-      cd = CharDet.detect(data)
-      data = cd.confidence > 0.6 ? Iconv.conv(cd.encoding, "UTF-8", data) : data
-      @content ||= JSON.parse(data)
+    def territory(value)
+      tap { @options.merge!(:territory => value) }
     end
     
-    def download
-      @download ||= RestClient.get(url, :timeout => 10)
+    def result
+      @prime ? results.sort_by do |res|
+        res.popularity
+      end.reverse[0..6].map do |r|
+        song, artist = type_of(r)
+        
+        match = clean!([song, artist].join(" ")).split(/\s+/)
+        raw = clean!(search).split(/\s+/)
+
+        if raw.length < match.length
+          diff = match - raw
+          res = diff.length.to_f/match.length
+        else
+          diff = raw - match
+          res = diff.length.to_f/raw.length
+        end
+
+        if diff.length > 1 and not match.map{ |m| diff.include?(m) }.all?
+          res =+ diff.map do |value|
+            match.map do |m|
+              Levenshtein.distance(value, m)
+            end.inject(:+)
+          end.inject(:+) / @config[:offset]
+        end
+        
+        [res - r.popularity/@config[:popularity], r]
+      end.reject do |distance, song|
+        exclude?(song.to_s) or not song.valid?
+      end.sort_by do |distance, _|
+        distance
+      end.map(&:last).first : results.select(&:valid?).first
     end
     
-    def errors(error)
-      case error.to_s
-      when "403 Forbidden"
-        raise SpotContainer::RequestLimitError.new(url)
+    def type_of(r)
+      if @type == :songs
+        return r.name.to_s.downcase, r.artist.name.to_s.downcase
+      elsif @type == :artists
+        return r.song.title.to_s.downcase, r.name.to_s.downcase
       else
-        raise error
+        return "", r.artist.to_s.downcase
       end
     end
     
-    def generate_url(type)
-      "http://ws.spotify.com/search/1/#{type}.json?q=<SEARCH>&page=<PAGE>"
+    def exclude?(compare)
+      @exclude.
+        reject{ |value| @search.to_s.match(/#{value}/i) }.
+        map{ |value| compare.match(/#{value}/i) }.any?
+    end
+
+    #
+    # @value String To be cleaned
+    # @return String A cleaned string
+    #
+    def clean!(value)
+      Spot::Clean.new(value).process
+    end
+    
+    private
+      def url
+        @url ||= @methods[@type][:url].
+          gsub(/<SEARCH>/, URI.escape(search)).
+          gsub(/<PAGE>/, (@page || 1).to_s)
+      end
+      
+      def search(force = false)
+        return @_search if @_search
+        @_search = ""
+        @_search = ((@strip or force) ? clean!(@prefix) + " " : @prefix + " ") if @prefix
+        @_search += ((@strip or force) ? clean!(@search) : @search)
+      end
+      
+      def scrape
+        return @cache[@type] if @cache[@type]
+        
+        @cache[@type] = []; content[@methods[@type][:selector].to_s].each do |item|
+          item = @methods[@type][:class].new(item.merge(@options)) 
+          @cache[@type] << item if item.valid? or @prime
+        end
+        @cache[@type]
+      end
+      
+      def content
+        data = download
+
+        if encoding = data.detect_encoding[:encoding]
+          data = download.force_encoding(encoding)
+        else
+          data = download.strip
+        end
+
+        JSON.parse(data)
+      rescue ArgumentError
+        JSON.parse(download)
+      end
+      
+      def download
+        @download ||= RestClient.get(url, :timeout => 10)
+      end
+      
+      def errors(error)
+        case error.to_s
+        when "403 Forbidden"
+          raise Spot::RequestLimitError.new(url)
+        else
+          raise error
+        end
+      end
+      
+      def generate_url(type)
+        "http://ws.spotify.com/search/1/#{type}.json?q=<SEARCH>&page=<PAGE>"
+      end
     end
 end