rapgenius 0.1.0 → 1.0.0

data/lib/rapgenius/media.rb

@@ -0,0 +1,11 @@
+module RapGenius
+  class Media
+    attr_reader :type, :url, :provider
+
+    def initialize(kwargs)
+      @type = kwargs.delete(:type)
+      @url = kwargs.delete(:url)
+      @provider = kwargs.delete(:provider)
+    end
+  end
+end

data/lib/rapgenius/song.rb

@@ -1,65 +1,137 @@
 # encoding: utf-8
 module RapGenius
   class Song
-    include RapGenius::Scraper
+    include RapGenius::Client
+    attr_reader :id
 
-    def self.find(path)
-      self.new(path)
+    def self.find(id)
+      self.new(id: id).tap { |song| song.document }
     end
 
-    # Search for a song
-    #
-    # query - Song to search for
-    #
-    # Returns an Array of Song objects.
-    def self.search(query)
-      results = Client.search(query)
+    def initialize(kwargs = {})
+      @id = kwargs.delete(:id)
+      @artist = kwargs.delete(:artist)
+      @title  = kwargs.delete(:title)
+      self.url = "songs/#{@id}"
+    end
+
+    def response
+      document["response"]["song"]
+    end
 
-      results.split("\n").map do |song|
-        info, link, id = song.split('|')
-        artist, title  = info.force_encoding('UTF-8').split(' – ')
+    def artist
+      @artist ||= Artist.new(
+        name: response["primary_artist"]["name"],
+        id: response["primary_artist"]["id"],
+        type: :primary
+      )
+    end
 
-        new(link, artist: artist, title: title)
+    def featured_artists
+      @featured_artists ||= response["featured_artists"].map do |artist|
+        Artist.new(
+          name: artist["name"],
+          id: artist["id"],
+          type: :featured
+        )
       end
     end
 
-    def initialize(path, kwargs = {})
-      self.url = path
+    def url
+      response["url"]
+    end
 
-      @artist = kwargs.delete(:artist)
-      @title  = kwargs.delete(:title)
+    def producer_artists
+      @producer_artists ||= response["producer_artists"].map do |artist|
+        Artist.new(
+          name: artist["name"],
+          id: artist["id"],
+          type: :producer
+        )
+      end
     end
 
-    def artist
-      @artist ||= document.css('.song_title a').text
+    def artists
+      [artist] + featured_artists + producer_artists
     end
 
     def title
-      @title ||= document.css('.edit_song_description i').text
+      @title ||= response["title"]
     end
 
     def description
-      document.css('.description_body').text
+      @description ||= document["response"]["song"]["description"]["dom"]["children"].map do |node|
+        parse_description(node)
+      end.flatten.join("")
     end
 
     def images
-      document.css('meta[property="og:image"]').
-        map { |meta| meta.attr('content') }
+      @images ||= keys_with_images.map do |key|
+        node = response[key]
+        if node.is_a? Array
+          node.map { |subnode| subnode["image_url"] }
+        elsif node.is_a? Hash
+          node["image_url"]
+        else
+          return
+        end
+      end.flatten
+    end
+
+    def pyongs
+      response["pyongs_count"]
+    end
+
+    def hot?
+      response["stats"]["hot"]
+    end
+
+    def views
+      response["stats"]["pageviews"]
+    end
+
+    def concurrent_viewers
+      response["stats"]["concurrents"]
     end
 
-    def full_artist
-      document.css('meta[property="og:title"]').attr('content').to_s.
-        split(" – ").first
+    def media
+      response["media"].map do |m| 
+        Media.new(type: m["type"], provider: m["provider"], url: m["url"])
+      end
     end
 
-    def annotations
-      @annotations ||= document.css('.lyrics a').map do |a|
-        Annotation.new(
-          id: a.attr('data-id').to_s,
-          song: self,
-          lyric: a.text
+    def lines
+      @lines ||= response["lyrics"]["dom"]["children"].map do |node|
+        parse_lines(node)
+      end.flatten.compact
+    end
+
+    private
+
+    def parse_lines(node)
+      if node.is_a?(Array)
+        node.map { |subnode| parse_lines(subnode) }
+      elsif node.is_a?(String)
+        Line.new(
+          song: Song.new(id: @id),
+          lyric: node
+        )
+      elsif node.is_a?(Hash) && node["tag"] == "p"
+        parse_lines(node["children"])
+      elsif node.is_a?(Hash) && node["tag"] == "a"
+        Line.new(
+          song: Song.new(id: @id),
+          lyric: node["children"].select {|l| l.is_a? String }.join("\n"),
+          id: node["data"]["id"]
         )
+      else
+        return
       end
     end
+
+    def keys_with_images
+      %w{featured_artists producer_artists primary_artist}
+    end
+
   end
 end

data/lib/rapgenius/version.rb

@@ -1,3 +1,3 @@
 module RapGenius
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/rapgenius.gemspec

@@ -7,14 +7,14 @@ Gem::Specification.new do |s|
   s.version     = RapGenius::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Tim Rogers", "Robert Speicher"]
-  s.email       = ["me+rapgenius@timrogers.co.uk", "rspeicher@gmail.com"]
+  s.email       = ["me@timrogers.co.uk", "rspeicher@gmail.com"]
   s.homepage    = "https://github.com/timrogers/rapgenius"
   s.summary     = %q{A gem for accessing lyrics and explanations on RapGenius.com}
   s.description = %q{Up until until now, to quote RapGenius themselves,
-    "working at Rap Genius is the API". With this magical screen-scraping gem,
-    you can access the wealth of data on the internet Talmud in Ruby.}
+    "working at Rap Genius is the API". With this magical gem using the
+    private API in the 'Genius' iOS app you can access the wealth of data on
+    the internet Talmud in Ruby.}
 
-  s.add_runtime_dependency "nokogiri",    "~>1.6.0"
   s.add_runtime_dependency "httparty",    "~>0.11.0"
   s.add_development_dependency "rspec",   "~>2.14.1"
   s.add_development_dependency "mocha",   "~>0.14.0"
@@ -25,4 +25,5 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+  s.license       = 'MIT'
 end

data/spec/rapgenius/artist_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module RapGenius
+  describe Artist do
+    context "given Drake", vcr: { cassette_name: "artist-130" } do
+      subject(:artist) { described_class.find(130) }
+
+      its(:url) { should eq "http://rapgenius.com/artists/Drake" }
+      its(:name) { should eq "Drake" }
+      its(:image) { should eq "http://images.rapgenius.com/2b3fa8326a5277fa31f2012a7b581e2e.500x319x11.gif" }
+      its(:description) { should include "Drake is part of a generation of new rappers" }
+
+      context "#songs" do
+        subject { artist.songs }
+
+        # The iOS app only loads a certain number, and doesn't (appear to)
+        # support pagination
+        its(:count) { should eq 25}
+
+        its(:last) { should be_a Song }
+        its("last.title") { should eq "Bitch Is Crazy" }
+      end
+
+      context "a non-existent artist ID" do
+        subject(:artist) { described_class.find("bahahaha") }
+
+        it "raises an exception" do
+          expect { artist }.to raise_exception
+        end
+      end
+    end
+  end
+end

data/spec/rapgenius/client_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+class ClientTester
+  # On other classes, we don't expose this as we'd rather use this attribute
+  # for the URL of the song itself
+  attr_reader :url
+
+  include RapGenius::Client
+end
+
+module RapGenius
+  describe Client do
+
+    let(:client) { ClientTester.new }
+
+    describe "#url=" do
+      it "forms the URL with the base URL, if the current path is relative" do
+        client.url = "foobar"
+        client.url.should include RapGenius::Client::BASE_URL
+      end
+
+      it "leaves the URL as it is if already complete" do
+        client.url = "http://foobar.com/baz"
+        client.url.should eq "http://foobar.com/baz"
+      end
+    end
+
+    describe "#document" do
+      before { client.url = "http://foo.bar" }
+
+      context "with a failed request" do
+        before do
+          stub_request(:get, "http://foo.bar").to_return({body: '', status: 404})
+        end
+
+        it "raises a ScraperError" do
+          expect { client.document }.to raise_error(RapGenius::Error)
+        end
+      end
+    end
+  end
+end

data/spec/rapgenius/line_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module RapGenius
+  describe Line, vcr: { cassette_name: "line-2638695" } do
+
+    let(:line) { described_class.find("2638695") }
+    subject { line }
+
+    its(:id)       { should eq "2638695" }
+    its(:song)     { should be_a Song }
+    its(:lyric) { should eq "Versace, Versace, Medusa head on me like I'm 'luminati" }
+    its("explanations.first") { should include "Versace’s logo is the head of Medusa" }
+    its(:explanations) { should eq line.annotations }
+
+    context "a non-existent referent ID" do
+      let(:line) { described_class.find("bahahaha") }
+
+      it "raises an exception" do
+        expect { line }.to raise_exception
+      end
+    end
+  end
+end

data/spec/rapgenius/media_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module RapGenius
+  describe Media do
+
+    subject(:media) do
+      Media.new(
+        type: "foo",
+        url: "foo",
+        provider: "foo"
+      )
+    end
+
+    its(:type) { should eq "foo" }
+    its(:url) { should eq "foo" }
+    its(:provider) { should eq "foo" }
+
+  end
+end

data/spec/rapgenius/song_spec.rb

@@ -2,61 +2,63 @@ require 'spec_helper'
 
 module RapGenius
   describe Song do
-    context "given Big Sean's Control", vcr: {cassette_name: "big-sean-control-lyrics"} do
-      subject { described_class.new("Big-sean-control-lyrics") }
-
-      its(:url)         { should eq "http://rapgenius.com/Big-sean-control-lyrics" }
-      its(:title)       { should eq "Control" }
-      its(:artist)      { should eq "Big Sean" }
-      its(:description) { should include "blew up the Internet" }
-      its(:full_artist) { should include "(Ft. Jay Electronica & Kendrick Lamar)"}
-
-      describe "#images" do
-        it "should be an Array" do
-          subject.images.should be_an Array
-        end
+    context "given Migos's Versace", vcr: { cassette_name: "song-176872" } do
+      subject(:song) { described_class.find(176872) }
 
-        it "should include Big Sean's picture" do
-          subject.images.should include "http://s3.amazonaws.com/rapgenius/1375029260_Big%20Sean.png"
-        end
-      end
+      its(:url) { should eq "http://rapgenius.com/Migos-versace-lyrics" }
+      its(:title) { should eq "Versace" }
+  
+      its(:description) { should include "they absolutely killed it" }
 
-      describe "#annotations" do
-        it "should be an Array of Annotation objects" do
-          subject.annotations.should be_an Array
-          subject.annotations.first.should be_a Annotation
-        end
+      context "#artist" do
+        subject { song.artist }
+        it { should be_a Artist }
+        its(:name) { should eq "Migos" }
+      end
 
-        it "should be of a valid length" do
-          # Annotations get added and removed from the live site; we want our
-          # count to be somewhat accurate, within reason.
-          subject.annotations.length.should be_within(15).of(130)
-        end
+      context "#featured_artists" do
+        subject { song.featured_artists }
+        its(:length) { should eq 1 }
+        its("first.name") { should eq "Drake" }
+        its(:first) { should be_a Artist }
       end
-    end
 
-    describe '.find' do
-      it "returns a new instance at the specified path" do
-        i = described_class.find("foobar")
-        i.should be_a Song
-        i.url.should eq 'http://rapgenius.com/foobar'
+      context "#producer_artists" do
+        subject { song.producer_artists }
+        its(:length) { should eq 1 }
+        its("first.name") { should eq "Zaytoven" }
+        its(:first) { should be_a Artist }
       end
-    end
 
-    describe '.search', vcr: {cassette_name: 'song-search-big-sean-control'} do
-      let(:results) { described_class.search('Big Sean Control') }
+      context "#media" do
+        subject { song.media }
+        its(:length) { should eq 2 }
+        its(:first) { should be_a Media }
+        its("first.provider") { should eq "soundcloud" }
+      end
 
-      it "returns an Array of Songs" do
-        results.should be_an Array
-        results.first.should be_a Song
+      context "#lines" do
+        subject { song.lines }
+        its(:count) { should eq 81 }
+        its(:first) { should be_a Line }
+        its("first.id") { should eq "1983907" }
+        its("first.lyric") { should eq "[Verse 1: Drake]" }
+        its("first.explanations.first") { should include "Versace used his verse in this runway show" }
       end
 
-      describe 'assigned attributes' do
-        subject { results.first }
+      its(:images) { should include "http://images.rapgenius.com/2b3fa8326a5277fa31f2012a7b581e2e.500x319x11.gif" }
+      its(:pyongs) { should eq 22 }
+      its(:hot?) { should eq false }
+      its(:views) { should eq 1834811 }
+      its(:concurrent_viewers) { should eq 9 }
+    
 
-        its(:url)    { should eq "http://rapgenius.com/Big-sean-control-lyrics" }
-        its(:artist) { should eq "Big Sean (Ft. Jay Electronica & Kendrick Lamar)" }
-        its(:title)  { should eq "Control" }
+      context "a non-existent song ID" do
+        subject(:song) { described_class.find("bahahaha") }
+
+        it "raises an exception" do
+          expect { song }.to raise_exception
+        end
       end
     end
   end