musix_match 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+== MIT License
+ 
+Copyright (c) 2010, Andrea Franz - (http://gravityblast.com)
+ 
+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.rdoc

@@ -0,0 +1,96 @@
+= Musix Match
+
+     _                                                                              _
+    | |       _                                                            _       | |
+    | |      | |                                                          | |      | |
+    | | _  _ | |                                                          | | _  _ | |
+    | || || || |    MusixMatch is wrapper for the musixmatch.com API's.   | || || || |
+    | || || || |  With this library you can search for lyrics and tracks  | || || || |
+    | |  || || |        using the http://musixmatch.com service.          | |  || || |
+    |          |                                                          |          |
+    |          |                                                          |          |
+    \          /                                                          \          /
+     ----------                                                            ----------
+ 
+== Installation
+
+  gem install musix_match    
+
+== Usage
+
+  require 'musix_match'
+    
+  MusixMatch::API::Base.api_key = 'YOUR_API_KEY'
+
+=== Lyrics search
+
+  response = MusixMatch.search_lyrics(:q_artist => 'Pantera')
+  if response.status_code == 200
+    response.each do |lyrics|
+      puts "#{lyrics.lyrics_id}: #{lyrics.track_name} (#{lyrics.artist_name})"
+    end
+  end
+    
+Available options for the search_lyrics methods are:
+
+* q: string to be searched in every data field
+* q_track: string to be searched among tracks titles
+* q_artist: string to be searched among artists names
+* format: desired output format
+* page: requested page of results
+* page_size: desired number of items per result page
+    
+=== Getting lyrics
+
+  response = MusixMatch.get_lyrics(lyrics_id)
+  if response.status_code == 200 && lyrics = response.lyrics
+    puts lyrics.lyrics_body
+  end
+
+=== Track search
+
+  response = MusixMatch.search_track(:q_artist => 'Pantera')
+  if response.status_code == 200
+    response.each do |track|
+      puts "#{track.track_id}: #{track.track_name} (#{track.artist_name})"
+    end
+  end
+    
+=== Getting track
+
+  response = MusixMatch.get_track(track_id)
+  if response.status_code == 200 && track = response.track
+    puts "#{track.track_name} (#{track.artist_name})"
+    puts "Lyrics id: #{track.lyrics_id}"
+  end
+    
+== Lyrics
+
+The Lyrics object has the following attributes:
+
+* lyrics_id
+* lyrics_body
+* track_name
+* artist_name
+
+== Track
+
+The track object has the following attributes:
+
+* track_id
+* track_mbid
+* lyrics_id
+* track_name
+* artist_id
+* artist_mbid
+* artist_name
+
+== Links
+
+* Repository: git://github.com/pilu/musix_match.git
+* Musixmatch site: {musixmatch.com}[http://musixmatch.com]
+* Musixmatch API: {developer.musixmatch.com}[http://developer.musixmatch.com]
+
+== Author
+
+Andrea Franz - {http://gravityblast.com}[http://gravityblast.com]

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'json'
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "musix_match"
+    gemspec.summary = "API wrapper for musixmatch.com API's"
+    gemspec.description = "API wrapper for musixmatch.com API's"
+    gemspec.email = "andrea@gravityblast.com"
+    gemspec.homepage = "http://github.com/pilu/musix_match"
+    gemspec.authors = ["Andrea Franz"]
+    gemspec.files = FileList['LICENSE', 'README.rdoc', 'Rakefile', 'lib/**/*.rb', 'spec/**/*.rb']
+    gemspec.add_dependency('json')
+    gemspec.add_dependency('httparty', '>= 0.6.1')
+    gemspec.extra_rdoc_files = ['README.rdoc', 'LICENSE']
+    gemspec.rdoc_options = ['--main=README.rdoc', '--charset=UTF-8']
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/lib/musix_match/api/base.rb

@@ -0,0 +1,42 @@
+module MusixMatch
+  module API
+    class APIKeyNotSpecifiedException < Exception; end
+    
+    class Base
+      API_URL = 'http://api.musixmatch.com/ws/1.0'
+    
+      def self.api_key=(value)
+        @@api_key = value        
+      end
+    
+      def self.api_key
+        class_variable_defined?("@@api_key") ? @@api_key : nil
+      end
+    
+      def self.url_for(method, params={})      
+        params.merge!({ :apikey => api_key })
+        url_params = params.collect{|k, v| "#{k}=#{v}"}.join('&')
+        URI.escape("#{API_URL}/#{method}?#{url_params}")
+      end
+
+      def self.get(method, params={})
+        raise APIKeyNotSpecifiedException.new('You must specify the API key. MusixMatch::API::Base.api_key = "YOUR_API_KEY"') if api_key.nil?
+        response = HTTParty.get(url_for(method, params))
+        case response.parsed_response
+        when Hash
+          response.parsed_response
+        when String
+          JSON.parse(response.parsed_response)
+        end
+      end
+    
+      def api_key    
+        self.class.api_key
+      end        
+
+      def get(method, params={})
+        self.class.get(method, params)
+      end
+    end
+  end
+end

data/lib/musix_match/api/finder.rb

@@ -0,0 +1,23 @@
+module MusixMatch  
+  module API
+    class Finder < Base
+      def find_lyrics(lyrics_id)
+        response = get('lyrics.get', {:lyrics_id => lyrics_id})
+        LyricsFindResult.new(response)
+      end
+
+      def find_track(track_id)
+        response = get('track.get', {:track_id => track_id})
+        TrackFindResult.new(response)
+      end
+
+      def self.find_lyrics(lyrics_id)
+        Finder.new.find_lyrics(lyrics_id)
+      end
+
+      def self.find_track(track_id)
+        Finder.new.find_track(track_id)
+      end
+    end
+  end
+end

data/lib/musix_match/api/search.rb

@@ -0,0 +1,23 @@
+module MusixMatch  
+  module API
+    class Search < Base  
+      def search_lyrics(options={})
+        response = get('lyrics.search', options)
+        LyricsSearchResult.new(response)
+      end
+
+      def search_track(options={})
+        response = get('track.search', options)
+        TrackSearchResult.new(response)
+      end
+
+      def self.search_lyrics(options={})
+        Search.new.search_lyrics(options)
+      end
+
+      def self.search_track(options={})
+        Search.new.search_track(options)
+      end
+    end
+  end
+end

data/lib/musix_match/lyrics_find_result.rb

@@ -0,0 +1,28 @@
+module MusixMatch
+  class LyricsFindResult    
+    attr_reader :status_code, :execute_time, :lyrics
+    
+    def initialize(response)
+      parse_response(response)
+    end        
+  
+  protected
+    
+    def parse_response(response)
+      parse_response_header(response)
+      parse_response_body(response)
+    end
+
+    def parse_response_header(response)
+      [:status_code, :execute_time].each do |key|
+        instance_variable_set "@#{key}", response['message']['header'][key.to_s]
+      end
+    end  
+  
+    def parse_response_body(response)
+      if status_code == 200
+        @lyrics = Models::Lyrics.new(response['message']['body']['lyrics_list']['lyrics'])
+      end
+    end
+  end
+end

data/lib/musix_match/lyrics_search_result.rb

@@ -0,0 +1,35 @@
+module MusixMatch
+  class LyricsSearchResult    
+    attr_reader :status_code, :execute_time, :available
+    
+    def initialize(response)
+      @lyrics_list = []
+      parse_response(response)
+    end
+  
+    def each
+      @lyrics_list.each do |lyrics|
+        yield lyrics
+      end
+    end 
+  
+  protected
+    
+    def parse_response(response)
+      parse_response_header(response)
+      parse_response_body(response)
+    end
+
+    def parse_response_header(response)
+      [:status_code, :execute_time, :available].each do |key|
+        instance_variable_set "@#{key}", response['message']['header'][key.to_s]
+      end
+    end  
+  
+    def parse_response_body(response)
+      response['message']['body']['lyrics_list'].each do |obj|
+        @lyrics_list << Models::Lyrics.new(obj['lyrics'])
+      end
+    end
+  end
+end

data/lib/musix_match/models/lyrics.rb

@@ -0,0 +1,9 @@
+module MusixMatch
+  module Models
+    class Lyrics
+      include Model
+      
+      model_with_attributes :lyrics_id, :lyrics_body, :track_name, :artist_name
+    end
+  end
+end

data/lib/musix_match/models/model.rb

@@ -0,0 +1,37 @@
+module MusixMatch
+  module Models    
+    module Model
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        ModelBuilder.build_constructor(self)
+      end            
+            
+      module ClassMethods
+        def model_with_attributes(*attributes)
+          attr_accessor(*attributes)
+          ModelBuilder.build_constructor(self, *attributes)
+        end
+        
+        def search(options={})
+          API::Search.send("search_#{self.name.split('::').last.downcase}", options)
+        end
+        
+        def get(item_id)
+          API::Finder.send("find_#{self.name.split('::').last.downcase}", item_id)
+        end                
+      end
+    end
+    
+    module ModelBuilder            
+      def self.build_constructor(base, *attributes)        
+        initialize_method = Proc.new do |*params|
+          model_params = params.first || {}
+          attributes.each do |attribute|
+            instance_variable_set("@#{attribute}", model_params.delete(attribute.to_s))
+          end
+        end      
+        base.send(:define_method, :initialize, &initialize_method)
+      end            
+    end        
+  end
+end

data/lib/musix_match/models/track.rb

@@ -0,0 +1,9 @@
+module MusixMatch
+  module Models
+    class Track
+      include Model
+      
+      model_with_attributes :track_id, :track_mbid, :lyrics_id, :track_name, :artist_id, :artist_mbid, :artist_name
+    end
+  end
+end

data/lib/musix_match/track_find_result.rb

@@ -0,0 +1,28 @@
+module MusixMatch
+  class TrackFindResult    
+    attr_reader :status_code, :execute_time, :track
+    
+    def initialize(response)
+      parse_response(response)
+    end        
+  
+  protected
+    
+    def parse_response(response)
+      parse_response_header(response)
+      parse_response_body(response)
+    end
+
+    def parse_response_header(response)
+      [:status_code, :execute_time].each do |key|
+        instance_variable_set "@#{key}", response['message']['header'][key.to_s]
+      end
+    end  
+  
+    def parse_response_body(response)
+      if status_code == 200
+        @track = Models::Track.new(response['message']['body']['track_list']['track'])
+      end
+    end
+  end
+end

data/lib/musix_match/track_search_result.rb

@@ -0,0 +1,35 @@
+module MusixMatch
+  class TrackSearchResult    
+    attr_reader :status_code, :execute_time, :available
+    
+    def initialize(response)
+      @track_list = []
+      parse_response(response)
+    end
+  
+    def each
+      @track_list.each do |lyrics|
+        yield lyrics
+      end
+    end
+  
+  protected
+    
+    def parse_response(response)
+      parse_response_header(response)
+      parse_response_body(response)
+    end
+
+    def parse_response_header(response)
+      [:status_code, :execute_time, :available].each do |key|
+        instance_variable_set "@#{key}", response['message']['header'][key.to_s]
+      end
+    end  
+  
+    def parse_response_body(response)
+      response['message']['body']['track_list'].each do |obj|        
+        @track_list << Models::Track.new(obj['track'])
+      end
+    end
+  end
+end

data/lib/musix_match.rb

@@ -0,0 +1,42 @@
+require 'uri'
+
+gem_libs = %w(json httparty)
+begin
+  gem_libs.each{|lib| require lib}
+rescue LoadError
+  require 'rubygems'
+  gem_libs.each{|lib| require lib}
+end
+
+musix_match_path = File.dirname(__FILE__)
+
+['api/base',
+'models/model',
+'models/lyrics',
+'lyrics_search_result',
+'track_search_result',
+'api/search',
+'lyrics_find_result',
+'track_find_result',
+'api/finder',
+'models/track'].each do |lib|
+  require musix_match_path + '/musix_match/' + lib
+end
+
+module MusixMatch
+  def self.get_lyrics(*args)
+    Models::Lyrics.get(*args)
+  end
+  
+  def self.search_lyrics(*args)
+    Models::Lyrics.search(*args)
+  end
+  
+  def self.get_track(*args)
+    Models::Track.get(*args)
+  end
+  
+  def self.search_track(*args)
+    Models::Track.search(*args)
+  end
+end

data/spec/finder_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Finder' do
+  
+  lyrics_find_response  = {'message' => {'body' => {'lyrics_list' => {'lyrics' => {}}}, 'header' => { 'status_code' => 200, 'execute_time' => 1 }}}
+  track_find_response   = {'message' => {'body' => {'track_list' => {'track' => {}} }, 'header' => { 'status_code' => 200, 'execute_time' => 1 }}}
+  
+  it "should initialize a new Finder object and call find_lyrics" do
+    finder = mock(MusixMatch::API::Finder)
+    MusixMatch::API::Finder.should_receive(:new).and_return(finder)
+    lyrics_id = 1
+    finder.should_receive(:find_lyrics).with(lyrics_id)
+    MusixMatch::API::Finder.find_lyrics(lyrics_id)
+  end
+  
+  it "should call get with lyrics.get and initialize a LyricsFindResult object" do    
+    finder = MusixMatch::API::Finder.new
+    lyrics_id = 1
+    finder.should_receive(:get).with('lyrics.get', :lyrics_id => lyrics_id).and_return(lyrics_find_response)
+    MusixMatch::LyricsFindResult.should_receive(:new).with(lyrics_find_response)
+    finder.find_lyrics(lyrics_id)
+  end
+  
+  it "should initialize a new Finder object and call find_track" do
+    finder = mock(MusixMatch::API::Finder)
+    MusixMatch::API::Finder.should_receive(:new).and_return(finder)
+    track_id = 1
+    finder.should_receive(:find_track).with(track_id)
+    MusixMatch::API::Finder.find_track(track_id)
+  end
+  
+  it "should call get with track.get and initialize a TrackFinderResult" do
+    finder = MusixMatch::API::Finder.new
+    track_id = 1
+    finder.should_receive(:get).with('track.get', :track_id => track_id).and_return(track_find_response)
+    MusixMatch::TrackFindResult.should_receive(:new).with(track_find_response)
+    finder.find_track(track_id)
+  end    
+end

data/spec/lyrics_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'Lyrics' do
+  it 'should call search_lyrics on Search class' do
+    params = { :q_artist => 'artist name' }
+    MusixMatch::API::Search.should_receive(:search_lyrics).with(params)
+    MusixMatch::Models::Lyrics.search(params)
+  end
+  
+  it 'should call find_lyrics on Finder class' do
+    lyrics_id = 1
+    MusixMatch::API::Finder.should_receive(:find_lyrics).with(lyrics_id)
+    MusixMatch::Models::Lyrics.get(lyrics_id)
+  end
+  
+  context 'when created' do
+    it 'should have the search class method' do
+      MusixMatch::Models::Lyrics.should respond_to(:search)
+    end
+    
+    it 'should have the get class method' do
+      MusixMatch::Models::Lyrics.should respond_to(:get)
+    end
+  end
+    
+  context 'when initialized' do
+    it 'should set lyrics_id' do
+      lyrics_id = 1
+      lyrics = MusixMatch::Models::Lyrics.new('lyrics_id' => lyrics_id)
+      lyrics.lyrics_id.should == lyrics_id
+    end
+    
+    it 'should set lyrics_body' do
+      lyrics_body = "lyrics body"
+      lyrics = MusixMatch::Models::Lyrics.new('lyrics_body' => lyrics_body)
+      lyrics.lyrics_body.should == lyrics_body
+    end
+    
+    it 'should set track_name' do
+      track_name = "track name"
+      lyrics = MusixMatch::Models::Lyrics.new('track_name' => track_name)
+      lyrics.track_name.should == track_name
+    end
+    
+    it 'should set artist_name' do
+      artist_name = "artist name"
+      lyrics = MusixMatch::Models::Lyrics.new('artist_name' => artist_name)
+      lyrics.artist_name.should == artist_name
+    end
+  end
+end

data/spec/musix_match_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'MusixMatch' do
+  it "should call get on Lyrics" do
+    lyrics_id = 1
+    MusixMatch::Models::Lyrics.should_receive(:get).with(lyrics_id)
+    MusixMatch.get_lyrics(lyrics_id)
+  end
+  
+  it "should call get on Track" do
+    track_id = 1
+    MusixMatch::Models::Track.should_receive(:get).with(track_id)
+    MusixMatch.get_track(track_id)
+  end
+  
+  it "should call search on Lyrics" do
+    params = { :q_artist => 'artist name' }
+    MusixMatch::Models::Lyrics.should_receive(:search).with(params)
+    MusixMatch.search_lyrics(params)
+  end
+  
+  it "should call search on Track" do
+    params = { :q_artist => 'artist name' }
+    MusixMatch::Models::Track.should_receive(:search).with(params)
+    MusixMatch.search_track(params)
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Search' do
+  
+  lyrics_search_response  = {'message' => {'body' => {'lyrics_list' => []}, 'header' => { 'status_code' => 200, 'execute_time' => 1, 'available' => 10 }}}
+  track_search_response   = {'message' => {'body' => {'track_list' => [] }, 'header' => { 'status_code' => 200, 'execute_time' => 1, 'available' => 10 }}}
+  
+  it "should initialize a new Search object and call search_lyrics" do
+    search = mock(MusixMatch::API::Search)
+    MusixMatch::API::Search.should_receive(:new).and_return(search)
+    options = { :q_artist => 'artist name' }
+    search.should_receive(:search_lyrics).with(options)
+    MusixMatch::API::Search.search_lyrics(options)
+  end
+  
+  it "should call get with lyrics.search and initialize a LyricsSearchResult object" do    
+    search = MusixMatch::API::Search.new
+    options = { :q_artist => 'artist name' }
+    search.should_receive(:get).with('lyrics.search', options).and_return(lyrics_search_response)
+    MusixMatch::LyricsSearchResult.should_receive(:new).with(lyrics_search_response)
+    search.search_lyrics(options)
+  end
+  
+  it "should initialize a new Search object and call search_track" do
+    search = mock(MusixMatch::API::Search)
+    MusixMatch::API::Search.should_receive(:new).and_return(search)
+    options = { :q_artist => 'artist name' }
+    search.should_receive(:search_track).with(options)
+    MusixMatch::API::Search.search_track(options)
+  end
+  
+  it "should call get with track.search and initialize a TrackSearchResult" do
+    search = MusixMatch::API::Search.new
+    options = { :q_artist => 'artist name' }    
+    search.should_receive(:get).with('track.search', options).and_return(track_search_response)
+    MusixMatch::TrackSearchResult.should_receive(:new).with(track_search_response)
+    search.search_track(options)
+  end    
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/musix_match'

data/spec/track_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe 'Track' do
+  it 'should call search_track on Search class' do
+    params = { :q_artist => 'artist name' }
+    MusixMatch::API::Search.should_receive(:search_track).with(params)
+    MusixMatch::Models::Track.search(params)
+  end
+  
+  it 'should call find_track on Finder class' do
+    track_id = 1
+    MusixMatch::API::Finder.should_receive(:find_track).with(track_id)
+    MusixMatch::Models::Track.get(track_id)
+  end
+  
+  context 'when created' do
+    it 'should have the search class method' do
+      MusixMatch::Models::Track.should respond_to(:search)
+    end
+    
+    it 'should have the get class method' do
+      MusixMatch::Models::Track.should respond_to(:get)
+    end
+  end
+  
+  context 'when initialized' do
+    it 'should set track_id' do
+      track_id = 1
+      track = MusixMatch::Models::Track.new('track_id' => track_id)
+      track.track_id.should == track_id
+    end
+    
+    it 'should set track_mbid' do
+      track_mbid = 1
+      track = MusixMatch::Models::Track.new('track_mbid' => track_mbid)
+      track.track_mbid.should == track_mbid
+    end
+    
+    it 'should set lyrics_id' do
+      lyrics_id = 1
+      track = MusixMatch::Models::Track.new('lyrics_id' => lyrics_id)
+      track.lyrics_id.should == lyrics_id
+    end
+    
+    it 'should set track_name' do
+      track_name = "track name"
+      track = MusixMatch::Models::Track.new('track_name' => track_name)
+      track.track_name.should == track_name
+    end
+    
+    it 'should set artist_id' do
+      artist_id = 1
+      track = MusixMatch::Models::Track.new('artist_id' => artist_id)
+      track.artist_id.should == artist_id
+    end
+    
+    it 'should set artist_mbid' do
+      artist_mbid = 1
+      track = MusixMatch::Models::Track.new('artist_mbid' => artist_mbid)
+      track.artist_mbid.should == artist_mbid
+    end
+    
+    it 'should set artist_name' do
+      artist_name = "artist name"
+      track = MusixMatch::Models::Track.new('artist_name' => artist_name)
+      track.artist_name.should == artist_name
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: musix_match
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrea Franz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-20 00:00:00 +02: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: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :runtime
+  version_requirements: *id002
+description: API wrapper for musixmatch.com API's
+email: andrea@gravityblast.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/musix_match.rb
+- lib/musix_match/api/base.rb
+- lib/musix_match/api/finder.rb
+- lib/musix_match/api/search.rb
+- lib/musix_match/lyrics_find_result.rb
+- lib/musix_match/lyrics_search_result.rb
+- lib/musix_match/models/lyrics.rb
+- lib/musix_match/models/model.rb
+- lib/musix_match/models/track.rb
+- lib/musix_match/track_find_result.rb
+- lib/musix_match/track_search_result.rb
+- spec/finder_spec.rb
+- spec/lyrics_spec.rb
+- spec/musix_match_spec.rb
+- spec/search_spec.rb
+- spec/spec_helper.rb
+- spec/track_spec.rb
+has_rdoc: true
+homepage: http://github.com/pilu/musix_match
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main=README.rdoc
+- --charset=UTF-8
+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.3.7
+signing_key: 
+specification_version: 3
+summary: API wrapper for musixmatch.com API's
+test_files: 
+- spec/finder_spec.rb
+- spec/lyrics_spec.rb
+- spec/musix_match_spec.rb
+- spec/search_spec.rb
+- spec/spec_helper.rb
+- spec/track_spec.rb