worth_watching 0.1.5 → 1.0.0

data/lib/worth_watching/reviews_fetcher.rb

@@ -0,0 +1,16 @@
+module WorthWatching
+
+  # General class to fetch movie reviews for a given movie
+  # Currently only supports RottenTomatoes as the source
+  class ReviewsFetcher
+    attr_accessor :rt_api_key
+
+    def initialize(rt_api_key)
+      @rt_api_key = rt_api_key
+    end
+
+    def fetch(rt_id)
+      RottenTomatoes::ReviewsFetcher.fetch(rt_id, rt_api_key)
+    end
+  end
+end

data/lib/worth_watching/rotten_tomatoes/movie_info_fetcher.rb

@@ -0,0 +1,23 @@
+require 'typhoeus'
+require 'json'
+
+module WorthWatching
+  module RottenTomatoes
+    class MovieInfoFetcher
+      attr_accessor :rt_api_key
+
+      def initialize(rt_api_key)
+        @rt_api_key = rt_api_key
+      end
+
+      # Fetches movie info of a single movie using the Rotten Tomatoes API, 
+      # and returns a Movie object
+      def fetch_info(rt_id)
+        uri = "#{RottenTomatoes::RT_API_BASE_URL}/movies/#{rt_id}.json?apikey=#{rt_api_key}"
+        movie_hash = JSON.parse(Typhoeus.get(uri).body)
+
+        RottenTomatoes::MovieParser.parse(movie_hash)
+      end
+    end
+  end
+end

data/lib/worth_watching/rotten_tomatoes/movie_list_fetcher.rb

@@ -0,0 +1,51 @@
+require 'typhoeus'
+require 'json'
+
+module WorthWatching
+  module RottenTomatoes
+    class MovieListFetcher
+      attr_accessor :rt_api_key
+
+      def initialize(rt_api_key)
+        @rt_api_key = rt_api_key
+      end
+
+      # Retrieve a list of basic movie information
+      #
+      # @param list_name [Symbol] type of list to retrieve, options:
+      # :box_office, :in_theaters, :opening, :upcoming, :top_rentals, 
+      # :current_releases, :new_releases, :upcoming_dvd
+      # @param country [Symbol] Country code for region-specific results (ISO 3166-1 alpha-2)
+      # @param result_limit [Symbol] no. of results to return, up to 16
+      # @return [Array] an array of results, each representing a movie in the list
+      def fetch_list(list_name, country, result_limit)
+        case list_name
+          # Build the appropriate URI based on the list name.
+          # Some endpoints use 'limit' to specify max results to return, some use 'page_limit'.
+          # Pass both to make the code simpler
+          when :box_office, :in_theaters, :opening, :upcoming
+            uri = "#{RottenTomatoes::RT_API_BASE_URL}/lists/movies/#{list_name.to_s}.json?limit=#{result_limit}"\
+                  "&page_limit=#{result_limit}&page=1&country=#{country.to_s}&apikey=#{@rt_api_key}"
+          when :top_rentals, :current_releases, :new_releases, :upcoming_dvd
+
+            # The API endpoint uses 'upcoming' for both DVD and cinema releases
+            # Need to avoid this clash by using ':upcoming_dvd' as possible method param,
+            # but change back when building the URI
+            list_name = :upcoming if list_name == :upcoming_dvd
+            uri = "#{RottenTomatoes::RT_API_BASE_URL}/lists/dvds/#{list_name.to_s}.json?limit=#{result_limit}"\
+                  "&page_limit=#{result_limit}&page=1&country=#{country.to_s}&apikey=#{@rt_api_key}"
+        end
+
+        response = JSON.parse(Typhoeus.get(uri).body)
+
+        response["movies"].map do |movie_hash|
+          { title: movie_hash["title"],
+            rt_id: movie_hash["id"],
+            year: movie_hash["year"].to_s,
+            rt_rating: movie_hash["ratings"]["critics_score"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/worth_watching/rotten_tomatoes/movie_parser.rb

@@ -0,0 +1,47 @@
+module WorthWatching
+  module RottenTomatoes
+    class MovieParser
+
+      # Parses a single movie JSON response from the Rotten Tomatoes API, returning
+      # a Movie object containing the movie's details
+      def self.parse(json_response)
+        movie_args = {}
+
+        movie_args[:title] = json_response['title']
+        movie_args[:plot] = json_response['synopsis']
+        movie_args[:director] = json_response['abridged_directors'][0]['name'] if json_response.has_key?('abridged_directors')
+        movie_args[:genre] = json_response['genres'][0] if json_response.has_key?('genres')
+
+        movie_args[:rt_rating] = json_response['ratings']['critics_score']
+        movie_args[:rt_url] = json_response['links']['alternate']
+
+        movie_args[:cast] = build_cast_list(json_response['abridged_cast'])
+
+        imdb_id = json_response['alternate_ids']['imdb'] if json_response.has_key?('alternate_ids')
+        movie_args[:imdb_id] = imdb_id
+
+        movie_args[:imdb_url] = "http://www.imdb.com/title/tt#{imdb_id}/"
+        movie_args[:release_date] = Date.parse(json_response['release_dates']['theater'])
+        movie_args[:rt_id] = json_response['id'].to_s
+
+        Movie.new(movie_args)
+      end
+
+      private
+
+      # Builds a cast list string from an array of actor names (up to 4 actors)
+      #
+      # @param cast [Array] the array of actor names
+      # @return [String] a string of actor names separated by commas
+      def self.build_cast_list(cast)
+        cast_list = cast[0..3].inject("") do |cast_list_string, actor, i|
+          cast_list_string << "#{actor["name"]}, "
+        end
+
+        # Remove the trailing comma
+        cast_list.sub(/, \z/, "")
+      end
+    end
+  end
+end
+

data/lib/worth_watching/rotten_tomatoes/review_parser.rb

@@ -0,0 +1,22 @@
+module WorthWatching
+  module RottenTomatoes
+    class ReviewParser
+
+      # Parses a JSON response of movie reviews from the Rotten Tomatoes API, returning
+      # an array WrittenReview objects
+      def self.parse(json_response)
+        json_response["reviews"].map do |review_hash|
+          author = review_hash["critic"]
+          date = Date.parse(review_hash["date"])
+          rating = review_hash["freshness"]
+          source = review_hash["publication"]
+          quote = review_hash["quote"]
+          link = review_hash["links"]["review"]
+          original_score = review_hash["original_score"] || "N/A"
+
+          WrittenReview.new(author, date, rating, source, quote, link, original_score)
+        end
+      end
+    end
+  end
+end

data/lib/worth_watching/rotten_tomatoes/reviews_fetcher.rb

@@ -0,0 +1,19 @@
+require 'typhoeus'
+require 'json'
+
+module WorthWatching
+  module RottenTomatoes
+    class ReviewsFetcher
+
+      # Fetches reviews using the Rotten Tomatoes API, 
+      # and returns an array of WrittenReview objects
+      def self.fetch(rt_id, rt_api_key)
+        uri = "#{RottenTomatoes::RT_API_BASE_URL}/movies/#{rt_id}/reviews.json?review_type=top_critic"\
+              "&page_limit=5&page=1&country=uk&apikey=#{rt_api_key}"
+        reviews_response = JSON.parse(Typhoeus.get(uri).body)
+
+        ReviewParser.parse(reviews_response)
+      end
+    end
+  end
+end

data/lib/worth_watching/rotten_tomatoes/rotten_tomatoes.rb

@@ -0,0 +1,5 @@
+module WorthWatching
+  module RottenTomatoes
+    RT_API_BASE_URL = 'http://api.rottentomatoes.com/api/public/v1.0'
+  end
+end

data/lib/worth_watching/rotten_tomatoes/searcher.rb

@@ -0,0 +1,37 @@
+require 'typhoeus'
+require 'json'
+require 'cgi'
+
+module WorthWatching
+  module RottenTomatoes
+    class Searcher
+
+      def initialize(rt_api_key)
+        @rt_api_key = rt_api_key
+      end
+
+      # Search for movies using a query string. Returns a max of 4 results
+      #
+      # @param movie_title [String] the title of the movie to search for
+      # @param result_limit [Integer] the max number of results to return
+      # @return [Array, false] an array containing hashes represting each movie in the search results, or
+      #   false if no results are found.
+      def search_by_title(movie_title, result_limit)
+        uri = "#{RottenTomatoes::RT_API_BASE_URL}/movies.json?apikey=#{@rt_api_key}&q=#{CGI::escape(movie_title)}&page_limit=#{result_limit}"
+
+        response = JSON.parse(Typhoeus.get(uri).body)
+
+        if response["total"] == 0
+          return false
+        else
+          # Build the array of movie serach results. Have to use a regexp to extract the Rotten Tomatoes
+          # ID from the movie link since the API does not return it directly.
+          return response["movies"].inject([]) do |movie_list, movie|
+            movie_list << { :title => movie["title"], :rt_id => movie["links"]["self"].match(/\/[0-9]+\./).to_s.gsub(/[\/\.]/, ""), :year => movie["year"].to_s }
+            movie_list
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worth_watching/tmdb/poster_fetcher.rb

@@ -0,0 +1,26 @@
+require 'typhoeus'
+require 'json'
+
+module WorthWatching
+  module TMDB
+    TMDB_API_BASE_URL = 'http://api.themoviedb.org/3'
+    class PosterFetcher
+      attr_accessor :tmdb_api_key
+
+      def initialize(tmdb_api_key)
+        @tmdb_api_key = tmdb_api_key
+      end
+
+      def fetch(imdb_id)
+        uri = "#{TMDB::TMDB_API_BASE_URL}/movie/tt#{imdb_id}?api_key=#{tmdb_api_key}"
+        movie_info = JSON.parse(Typhoeus.get(uri).body)
+
+        if movie_info.has_key?("poster_path")
+          "http://cf2.imgobject.com/t/p/original" + movie_info["poster_path"]
+        else
+          "No poster available"
+        end
+      end
+    end
+  end
+end

data/lib/worth_watching/version.rb

@@ -1,3 +1,3 @@
 module WorthWatching
-  VERSION = "0.1.5"
+  VERSION = "1.0.0"
 end

data/lib/worth_watching/written_review.rb

@@ -4,14 +4,14 @@ module WorthWatching
   class WrittenReview
     attr_accessor :author, :date, :rating, :source, :quote, :link, :original_score
 
-    def initialize(review_hash)
-      @author = review_hash["critic"]
-      @date = Date.parse(review_hash["date"])
-      @rating = review_hash["freshness"]
-      @source = review_hash["publication"]
-      @quote = review_hash["quote"]
-      @link = review_hash["links"]["review"]
-      @original_score = review_hash["original_score"] || "N/A"
+    def initialize(author, date, rating, source, quote, link, original_score)
+      @author = author
+      @date = date
+      @rating = rating
+      @source = source
+      @quote = quote
+      @link = link
+      @original_score = original_score
     end
 
     def to_s
@@ -19,13 +19,13 @@ module WorthWatching
     end
 
     def to_hash
-      { author: @author,
-        date: @date,
-        rating: @rating,
-        source: @source,
-        quote: @quote,
-        link: @link,
-        original_score: @original_score
+      { author: author,
+        date: date,
+        rating: rating,
+        source: source,
+        quote: quote,
+        link: link,
+        original_score: original_score
       }
     end
   end

data/spec/{unit/aggregator_spec.rb → integration/aggregating_a_movie_spec.rb}

@@ -1,23 +1,27 @@
-require 'test_helper'
+require 'spec_helper'
 
-describe 'WorthWatching::Aggregator' do
-
-  let(:aggregator) {WorthWatching::Aggregator.new("rt_api_key", "tmdb_api_key")}
+describe "Aggregating a movie" do
+  let(:aggregator) { WorthWatching::Aggregator.new("rt_api_key", "tmdb_api_key") }
 
   describe 'retrieving individual movie info' do
     before do
+      # Single movie RottenTomatoes
       json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/toy_story_rt.json")
       stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\/770672122\.json\?apikey\=.*/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
 
+      # Single movie OMDB
       json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/toy_story_omdb.json")
       stub_request(:get, "http://www.omdbapi.com/?i=tt0435761").to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
 
+      # Single movie TMDB
       json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/toy_story_tmdb.json")
       stub_request(:get, /api\.themoviedb\.org\/3\/movie\/tt0435761\?api_key\=.*/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
 
+      # RottenTomatoes reviews
       json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/toy_story_reviews_rt.json")
       stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\/770672122\/reviews\.json\?apikey\=.*&country=uk&page=1&page_limit=5&review_type=top_critic/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
 
+      # Single movie MetaCritic
       json_response = File.read(File.dirname(__FILE__) + "/../support/html_responses/toy_story_mc.html")
       stub_request(:get, "http://www.metacritic.com/search/movie/Toy+Story+3/results").to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["text/html; charset=utf-8"]})
     end
@@ -35,7 +39,7 @@ describe 'WorthWatching::Aggregator' do
     end
 
     it "should have IMDB rating of 8.5" do
-      expect(movie.imdb_rating).to eq("8.5")
+      expect(movie.imdb_rating).to eq(8.5)
     end
 
     it "should have IMDB url 'http://www.imdb.com/title/tt0435761/'" do
@@ -43,7 +47,7 @@ describe 'WorthWatching::Aggregator' do
     end
 
     it "should have metacritic rating of 92" do
-      expect(movie.metacritic_rating).to eq("92")
+      expect(movie.metacritic_rating).to eq(92)
     end
 
     it "should have metacritic url 'http://www.metacritic.com/movie/toy-story-3'" do
@@ -87,7 +91,7 @@ describe 'WorthWatching::Aggregator' do
       end
     end
 
-    context "when the OMDB API has not IMDb rating info for a movie" do
+    context "when the OMDB API has no IMDb rating info for a movie" do
       before do
         json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/captain_america_rt.json")
         stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\/771312513\.json\?apikey\=.*/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
@@ -115,47 +119,16 @@ describe 'WorthWatching::Aggregator' do
     end
   end
 
-  describe "searching for movies" do
+  context "when the Rotten Tomatoes API does not return the IMDb ID of the movie" do
     before do
-      json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/1_movie_search_result.json")
-      stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\.json\?apikey=.*&page_limit=4&q=finding%20nemo/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
-
-      json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/3_movie_search_result.json")
-      stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\.json\?apikey=.*&page_limit=4&q=toy%20story/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
-
-      json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/0_movie_search_result.json")
-      stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\.json\?apikey=.*&page_limit=4&q=amoviethatdoesnotexist/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
+      # Single movie RottenTomatoes, with insufficient data
+      json_response = File.read(File.dirname(__FILE__) + "/../support/json_responses/a_movie_with_little_info_rt.json")
+      stub_request(:get, /api\.rottentomatoes\.com\/api\/public\/v1\.0\/movies\/11111111\.json\?apikey\=.*/).to_return(:status => 200, :body => json_response,:headers => {"content-type"=>["application/json; charset=utf-8"]})
     end
 
-    context "when results exist for the given query string" do
-      let(:results) { aggregator.search_by_title("finding nemo", 4) }
-      describe "the search results" do
-        it "is an array of movies" do
-
-          expect(results).to be_an_instance_of(Array)
-        end
-
-        it "has the title of the movie result" do
-          expect(results.first[:title]).to eq("Finding Nemo")
-        end
-
-        it "has the Rotten Tomatoes ID of the movie result" do
-          expect(results.first[:rt_id]).to eq("9377")
-        end
-
-        it "has the release year of the movie result" do
-          expect(results.first[:year]).to eq("2003")
-        end
-      end
-    end
-
-    context "when results do not exist for the given query string" do
-      describe "the search results" do
-        it "returns false" do
-          results = aggregator.search_by_title("amoviethatdoesnotexist", 4)
-          expect(results).to be_false
-        end
-      end
+    it "raises an exception" do
+      expect { aggregator.aggregate_movie("11111111") }.to raise_exception(InsufficientDataError,
+                                                                           "No IMDb ID present, can't aggregate")
     end
   end
 end

data/spec/support/json_responses/a_movie_with_little_info_rt.json

@@ -0,0 +1 @@
+{"id":111111,"title":"A Movie From The Future","year":2020,"mpaa_rating":"G","runtime":103,"critics_consensus":"Deftly blending comedy, adventure, and honest emotion, Toy Story 3 is a rare second sequel that really works.","release_dates":{"theater":"2010-06-18","dvd":"2010-11-02"},"ratings":{"critics_rating":"Certified Fresh","critics_score":99,"audience_rating":"Upright","audience_score":89},"synopsis":"Pixar returns to their first success with Toy Story 3. The movie begins with Andy leaving for college and donating his beloved toys -- including Woody (Tom Hanks) and Buzz (Tim Allen) -- to a daycare. While the crew meets new friends, including Ken (Michael Keaton), they soon grow to hate their new surroundings and plan an escape. The film was directed by Lee Unkrich from a script co-authored by Little Miss Sunshine scribe Michael Arndt. ~ Perry Seibert, Rovi","posters":{"thumbnail":"http://content6.flixster.com/movie/11/13/43/11134356_mob.jpg","profile":"http://content6.flixster.com/movie/11/13/43/11134356_pro.jpg","detailed":"http://content6.flixster.com/movie/11/13/43/11134356_det.jpg","original":"http://content6.flixster.com/movie/11/13/43/11134356_ori.jpg"},"abridged_cast":[{"name":"Tom Hanks","id":"162655641","characters":["Woody"]},{"name":"Tim Allen","id":"162655909","characters":["Buzz Lightyear"]},{"name":"Joan Cusack","id":"162655020","characters":["Jessie the Cowgirl"]},{"name":"Ned Beatty","id":"162672460","characters":["Lots-o'-Huggin' Bear","Lotso"]},{"name":"Don Rickles","id":"341817905","characters":["Mr. Potato Head"]}],"studio":"Walt Disney Pictures","links":{"self":"http://api.rottentomatoes.com/api/public/v1.0/movies/770672122.json","alternate":"http://www.rottentomatoes.com/m/toy_story_3/","cast":"http://api.rottentomatoes.com/api/public/v1.0/movies/770672122/cast.json","clips":"http://api.rottentomatoes.com/api/public/v1.0/movies/770672122/clips.json","reviews":"http://api.rottentomatoes.com/api/public/v1.0/movies/770672122/reviews.json","similar":"http://api.rottentomatoes.com/api/public/v1.0/movies/770672122/similar.json"}}

data/spec/unit/imdb/rating_fetcher_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "WorthWatching::IMDB::RatingFetcher" do
+  before do
+    # Single movie OMDB (Toy Story 3)
+    json_response = File.read(File.dirname(__FILE__) + "/../../support/json_responses/toy_story_omdb.json")
+    stub_request(:get, "http://www.omdbapi.com/?i=tt0435761").to_return(:status => 200, :body => json_response)
+
+    # Single movie OMDB (Captain America)
+    json_response = File.read(File.dirname(__FILE__) + "/../../support/json_responses/captain_america_omdb.json")
+    stub_request(:get, "http://www.omdbapi.com/?i=tt1843866").to_return(:status => 200, :body => json_response)
+
+    # IMDb movie webpage (Captain America)
+    json_response = File.read(File.dirname(__FILE__) + "/../../support/html_responses/captain_america_imdb.html")
+    stub_request(:get, "http://m.imdb.com/title/tt1843866/").to_return(:status => 200, :body => json_response)
+  end
+
+  context "when the rating is available using the OMDB API" do
+    it "returns the correct IMDb rating via the OMDB API" do
+      rating = WorthWatching::IMDB::RatingFetcher.fetch("0435761")
+      expect(rating).to eq(8.5)
+    end
+  end
+
+  context "when the rating is not available using the OMDB API" do
+    it "returns the correct IMDb rating by screenscraping its IMDb webpage" do
+      rating = WorthWatching::IMDB::RatingFetcher.fetch("1843866")
+      expect(rating).to eq(8.3)
+    end
+  end
+end