worth_watching 0.1.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8625dab449c3f89b26961b8a19958909187bf6fe
-  data.tar.gz: 55669a5c1404095f1a8ddfe9846fbc61e2597ce3
+  metadata.gz: 8c86cd8984aed68285c27d7efc4468c99a7bfac8
+  data.tar.gz: 5b494c7a1279f7b892bc77f4ced8476936d9f88d
 SHA512:
-  metadata.gz: c522013091038f067811b6003c0c5b7e3325952f7c2b810d61128582903d0f0ad5038f08579ae13d26704ff012151c4891cccdf4544ce79922b791f6c8a9a45e
-  data.tar.gz: 57cd2e5787a86ed258d8248a696d0343546dfb18e26c4a714a7db0124eb77f9a6ae91cfdc351a847eba19e0923c8fe0212aa8b86fe8aa73b0f32309d45bc7414
+  metadata.gz: 0cc5edba36c66abec35fec8e47780c2b74c7e03a72381c407ac3d7defdb07d29616d6e572347698cc21ce205647cc033d0e1ccda43a6f640dafd23b7bf9af231
+  data.tar.gz: 777a90ae1caa2606a93d1eb81d0b170bcd77703cb1be2f66632b0e42743acd251a739e8cf6336d2133036e6fab823327fa9bfe8a5dca88f2e06038ad826ebc9a

data/README.md

@@ -76,7 +76,8 @@ Pass the title of the movie, and the maximum number of results to return
 # Search for movies by title. Returns an array of hashes, each hash representing
 # a movie in the search result
 # Note that it returns the Rotten Tomatoes ID for each movie, which is vital to aggregation
-movie_aggregator.search_by_title("the godfather", 4)
+searcher = WorthWatching::RottenTomatoes::Searcher.new("rt_api_key")
+searcher.search_by_title("the godfather", 4)
 => [{:title=>"The Godfather", :rt_id=>"12911", :year=>"1972"},
 {:title=>"The Godfather, Part II", :rt_id=>"12926", :year=>"1974"},
 {:title=>"The Godfather, Part III", :rt_id=>"13476", :year=>"1990"},
@@ -212,8 +213,7 @@ Rating: 4/5"
 
 ### Aggregating a list of movies
 The Rotten Tomatoes API supports a number of pre-defined lists for both cinema/theater
-releases and DVD releases. For example, if you want to aggregate info for each movie
-on the Box Office list (best performing cinema releases), WorthWatching supports this.
+releases and DVD releases.
 
 Pass the name of the list you would like to process (as a Symbol), the country code
 (ISO 3166-1 alpha-2) of the country you would like info to be localised to (as a Symbol),
@@ -233,47 +233,34 @@ ticket sales
 - ``:new_releases`` - new DVD releases
 - ``:upcoming_dvd`` - upcoming DVD releases
 
-**Be careful using this feature! Since WorthWatching will aggregate info for each movie on the list,
-there is the potential to make a significant number of API calls through repeated use.**
-
 **The Rotten Tomatoes API
 does have rate limits (as of March 2014: 5 calls a second, 10,000 calls a day)**
 
-
 ```ruby
+# Create a new fetcher using your API key
+list_fetcher = WorthWatching::RottenTomatoes::MovieListFetcher.new("rt_api_key")
 
-# Aggregate the top 4 box office movies in the UK
-top_movies = movie_aggregator.aggregate_list(:box_office, :uk, 4)
+# Get the top 4 box office movies in the UK
+list_fetcher.fetch_list(:box_office, :uk, 4)
+=> [{:title=>"A Most Wanted Man", :rt_id=>"771314084", :year=>"2014", :rt_rating=>91},
+ {:title=>"Before I Go to Sleep", :rt_id=>"771367646", :year=>"2014", :rt_rating=>58},
+ {:title=>"Let's Be Cops", :rt_id=>"771372963", :year=>"2014", :rt_rating=>20},
+ {:title=>"Magic in the Moonlight", :rt_id=>"771367659", :year=>"2014", :rt_rating=>51}]
 
 # Or the top 6 releases on DVD in the US
-top_dvds = movie_aggregator.aggregate_list(:top_rentals, :us, 6)
+top_dvds = list_fetcher.fetch_list(:top_rentals, :us, 6)
+=> [{:title=>"Captain America: The Winter Soldier", :rt_id=>"771312513", :year=>"2014", :rt_rating=>89},
+ {:title=>"The Amazing Spider-Man 2", :rt_id=>"771249926", :year=>"2014", :rt_rating=>53},
+ {:title=>"Godzilla", :rt_id=>"771225175", :year=>"2014", :rt_rating=>73},
+ {:title=>"Neighbors", :rt_id=>"771308254", :year=>"2014", :rt_rating=>73},
+ {:title=>"Divergent", :rt_id=>"771315918", :year=>"2014", :rt_rating=>41},
+ {:title=>"Noah", :rt_id=>"771305170", :year=>"2014", :rt_rating=>77}]
 
-# The above list-based methods return an array of Movie objects
-number_1_movie = top_movies.first
+# The above list-based methods return an array of hashes, each representing a result
+number_1_dvd = top_dvds.first
+=> {:title=>"Captain America: The Winter Soldier", :rt_id=>"771312513", :year=>"2014", :rt_rating=>89}
 
-number_1_movie.title
-=> "Captain America: The Winter Soldier"
+# Use the rt_id (Rotten Tomato ID) to subsequently aggregate movie info
+aggregated_results = top_dvds.map { |movie| aggregator.aggregate_movie(movie[:rt_id]) }
 
-number_1_movie.metacritic_rating
-=> 71
 ```
-
-### Why is the returned list empty?
-
-This may be because some movies do not have the minimum amount of data available
-in order to aggregate their rating info, and are therefore 'discarded' during the aggregation
-process.
-
-If a movie's IMDb ID is not available through the Rotten Tomatoes API, rating info
-cannot be retrieved.
-
-During testing I also noticed that movies with no available release date were likely
-to be very obscure and not have any rating info associated with them either. This is
-the other criteria for a movie being discarded.
-
-This only tends to happen with very small release independent films, particularly foreign ones.
-
-The lists where the above is most likely are ``:upcoming`` and ``:upcoming_dvd``, since they
-contain movies that probably don't have any rating info yet, as they haven't been released.
-
-The opposite is true for lists like ``:box_office`` and ``top_rentals``.

data/lib/worth_watching.rb

@@ -2,6 +2,23 @@ require "worth_watching/version"
 require 'worth_watching/aggregator'
 require 'worth_watching/movie'
 require 'worth_watching/written_review'
+require 'worth_watching/errors'
+
+require 'worth_watching/rotten_tomatoes/rotten_tomatoes'
+require 'worth_watching/rotten_tomatoes/movie_parser'
+require 'worth_watching/rotten_tomatoes/review_parser'
+require 'worth_watching/rotten_tomatoes/reviews_fetcher'
+require 'worth_watching/rotten_tomatoes/movie_info_fetcher'
+require 'worth_watching/rotten_tomatoes/movie_list_fetcher'
+require 'worth_watching/rotten_tomatoes/searcher'
+
+require 'worth_watching/imdb/rating_fetcher'
+
+require 'worth_watching/metacritic/rating_fetcher'
+
+require 'worth_watching/reviews_fetcher'
+
+require 'worth_watching/tmdb/poster_fetcher'
 
 module WorthWatching
-end
+end

data/lib/worth_watching/aggregator.rb

@@ -1,21 +1,12 @@
-require 'nokogiri'
-require 'typhoeus'
-require 'json'
-
 module WorthWatching
   class Aggregator
 
     attr_accessor :rt_api_key, :tmdb_api_key
     attr_reader :movie
 
-    RT_API_BASE_URL = 'http://api.rottentomatoes.com/api/public/v1.0'
-    TMDB_API_BASE_URL = 'http://api.themoviedb.org/3'
-
-    # Initialize a new Aggregator object to retrieve movie info
     def initialize(rt_api_key, tmdb_api_key)
       @rt_api_key = rt_api_key
       @tmdb_api_key = tmdb_api_key
-      @movie = nil # the current movie being aggregated
     end
 
     # Retrieve the details of a specific movie using its Rotten Tomatoes ID
@@ -23,188 +14,21 @@ module WorthWatching
     # @param rt_id [String] the Rotten Tomatoes ID of the movie
     # @return [Movie] a Movie object representing the movie
     def aggregate_movie(rt_id)
-      uri = "#{RT_API_BASE_URL}/movies/#{rt_id}.json?apikey=#{@rt_api_key}"
-      movie_hash = JSON.parse(Typhoeus.get(uri).body)
-
-      @movie = Movie.new(movie_hash)
-      aggregate
-    end
-
-    # Retrieve a list of movies, then aggregate info for each one
-    #
-    # @param list_name[Symbol] the name of the Rotten Tomato list. Possible values: :box_office,
-    #   :in_theaters, :opening, :upcoming, :top_rentals, :current_releases, :new_releases, :upcoming_dvd
-    # @param country [Symbol] Localised data for the selected country (ISO 3166-1 alpha-2)
-    # @param result_limit [Integer] the max number of movies to return in the list
-    # @return [Array] an array of Movie objects
-    def aggregate_list(list_name, country, result_limit)
-      case list_name
-
-        # Build the appropriate URI based on the list name.
-        # Some enpoints 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 = "#{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 = "#{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
-
-      get_movie_list(uri)
-    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 = "http://api.rottentomatoes.com/api/public/v1.0/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
-
-    private
-
-    # Aggregates extra info about @movie that cannot be derived directly from the
-    # Rotten Tomatoes API e.g IMDb/Metacritic rating, HQ posters
-    #
-    # @return [Movie] the movie with aggregated info completed
-    def aggregate
-      retrieve_imdb_info
-      retrieve_metacritic_info
-      get_poster
-      get_reviews
-      return @movie
-    end
-
-    # Retrieves and updates the current movie's IMDb rating
-    def retrieve_imdb_info
-      omdb_response = JSON.parse(Typhoeus.get("http://www.omdbapi.com/?i=tt#{@movie.imdb_id}").body)
-
-      if omdb_response["Response"] == "True"
-        if omdb_response["imdbRating"] == "N/A"
-          scrape_imdb_rating
-        else
-          @movie.imdb_rating = omdb_response["imdbRating"]
-        end
-      else
-        @movie.imdb_rating = "Unavailable"
-      end
-    end
 
-    # Retrieves and updates the current movie's Metacritic rating and URL
-    def retrieve_metacritic_info
-      metacritic_page = Nokogiri::HTML(Typhoeus.get("http://www.metacritic.com/search/"\
-                                       "movie/#{CGI.escape(@movie.title)}/results").body)
+      # Get the basic movie info first using the RottenTomatoes API
+      movie = RottenTomatoes::MovieInfoFetcher.new(rt_api_key).fetch_info(rt_id)
 
-      scraped_rating = metacritic_page.css('.first_result .metascore_w').text
-      metacritic_url = "http://www.metacritic.com#{metacritic_page.at_css('.first_result a').attr(:href)}"
+      raise(InsufficientDataError, "No IMDb ID present, can't aggregate") if movie.imdb_id == nil
 
-      # If attempt to scrape results in empty string, info must not be available
-      if scraped_rating == ""
-        scraped_rating = "No Rating"
-        metacritic_url = "No URL"
-      end
-
-      @movie.metacritic_rating = scraped_rating
-      @movie.metacritic_url = metacritic_url
-    end
-
-    # Scrapes and sets the IMDb rating of the current movie from its IMDb page
-    def scrape_imdb_rating
-      imdb_url = "http://m.imdb.com/title/tt#{@movie.imdb_id}/"
-
-      imdb_page = Nokogiri::HTML(Typhoeus.get(imdb_url).body)
-
-      @movie.imdb_rating = imdb_page.xpath("//*[@class = 'mobile-sprite yellow-star']").first.next_element.text.match(/[0-9]\.[0-9]/).to_s.to_f
-    end
-
-    # Updates the current movie's high resolution poster URL
-    def get_poster
-      uri = "#{TMDB_API_BASE_URL}/movie/tt#{@movie.imdb_id}?api_key=#{tmdb_api_key}"
-      movie_info = JSON.parse(Typhoeus.get(uri).body)
-
-      if movie_info.has_key?("poster_path")
-        @movie.poster = "http://cf2.imgobject.com/t/p/original" + movie_info["poster_path"]
-      else
-        @movie.poster = "No poster available"
-      end
-    end
-
-    # Retrieves and updates the current movie's reviews
-    def get_reviews
-      uri = "#{RT_API_BASE_URL}/movies/#{@movie.rt_id}/reviews.json?review_type=top_critic"\
-            "&page_limit=5&page=1&country=uk&apikey=#{@rt_api_key}"
-      review_hash = JSON.parse(Typhoeus.get(uri).body)
-
-      review_list = []
-
-      review_hash["reviews"].each do |review|
-        review_list << WrittenReview.new(review)
-      end
-
-      @movie.reviews = review_list
-    end
-
-    # Checks that a given movie has enough information available via API to aggregate
-    # data. It MUST have an IMDb id and a release date.
-    #
-    # @param [Hash] the hash representation of the movie to check
-    # @return [Boolean] whether the movie has a theater release date and IMDb ID
-    def enough_info?(movie)
-
-      has_release_date = false
-      has_imdb_id = false
-
-      if movie.has_key?("release_dates")
-        if movie["release_dates"].has_key?("theater")
-          has_release_date = !movie["release_dates"]["theater"].empty?
-        end
-      end
-
-      # Check IMDb ID is present
-      if movie.has_key?("alternate_ids")
-        if movie["alternate_ids"].has_key?("imdb")
-          has_imdb_id = !movie["alternate_ids"]["imdb"].empty?
-        end
-      end
-      return has_release_date && has_imdb_id
-    end
-
-    # Retrieves a list of movies from the Rotten Tomatoes API, then aggregates
-    # info for each one
-    #
-    # @param uri [String] the Rotten Tomatoes API endpoint for the list
-    # @return [Array] an array of Movie objects
-    def get_movie_list(uri)
-      response = JSON.parse(Typhoeus.get(uri).body)
-      movie_list_response = response["movies"]
+      movie.imdb_rating = IMDB::RatingFetcher.fetch(movie.imdb_id)
 
-      movie_list = movie_list_response.inject([]) do |list, movie|
-        list << aggregate_movie(movie['id']) if enough_info?(movie)
-        list
-      end
+      metacritic_info = Metacritic::RatingFetcher.fetch(movie.title)
+      movie.metacritic_rating = metacritic_info[:metacritic_rating]
+      movie.metacritic_url = metacritic_info[:metacritic_url]
 
-      return movie_list
+      movie.poster = TMDB::PosterFetcher.new(@tmdb_api_key).fetch(movie.imdb_id)
+      movie.reviews = ReviewsFetcher.new(@rt_api_key).fetch(movie.rt_id)
+      @movie = movie
     end
   end
 end

data/lib/worth_watching/errors.rb

@@ -0,0 +1,2 @@
+class InsufficientDataError < Exception
+end

data/lib/worth_watching/imdb/rating_fetcher.rb

@@ -0,0 +1,38 @@
+require 'typhoeus'
+require 'json'
+require 'nokogiri'
+
+module WorthWatching
+  module IMDB
+    class RatingFetcher
+
+      # Fetches movie info of a single movie using the Rotten Tomatoes API, 
+      # and returns a Movie object
+      def self.fetch(imdb_id)
+        omdb_response = JSON.parse(Typhoeus.get("http://www.omdbapi.com/?i=tt#{imdb_id}").body)
+
+        if omdb_response["Response"] == "True"
+          if omdb_response["imdbRating"] == "N/A"
+            scrape_imdb_rating(imdb_id)
+          else
+            imdb_rating = omdb_response["imdbRating"].to_f
+          end
+        else
+          imdb_rating = "Unavailable"
+        end
+      end
+
+      private 
+
+      # Scrapes and sets the IMDb rating of the current movie from its IMDb page
+      def self.scrape_imdb_rating(imdb_id)
+        imdb_url = "http://m.imdb.com/title/tt#{imdb_id}/"
+
+        imdb_page = Nokogiri::HTML(Typhoeus.get(imdb_url).body)
+
+        imdb_page.xpath("//*[@class = 'mobile-sprite yellow-star']").first.next_element.text.match(/[0-9]\.[0-9]/).to_s.to_f
+      end
+
+    end
+  end
+end

data/lib/worth_watching/metacritic/rating_fetcher.rb

@@ -0,0 +1,28 @@
+require 'typhoeus'
+require 'nokogiri'
+require 'cgi'
+
+module WorthWatching
+  module Metacritic
+    class RatingFetcher
+
+      # Fetches movie info of a single movie using the Rotten Tomatoes API, 
+      # and returns a Movie object
+      def self.fetch(movie_title)
+        metacritic_page = Nokogiri::HTML(Typhoeus.get("http://www.metacritic.com/search/"\
+                                         "movie/#{CGI.escape(movie_title)}/results").body)
+
+        scraped_rating = metacritic_page.css('.first_result .metascore_w').text.to_i
+        metacritic_url = "http://www.metacritic.com#{metacritic_page.at_css('.first_result a').attr(:href)}"
+
+        # If attempt to scrape results in empty string, info must not be available
+        if scraped_rating == ""
+          scraped_rating = "No Rating"
+          metacritic_url = "No URL"
+        end
+        
+        { metacritic_rating: scraped_rating, metacritic_url: metacritic_url }
+      end
+    end
+  end
+end

data/lib/worth_watching/movie.rb

@@ -1,24 +1,21 @@
-require 'date'
-
 module WorthWatching
   class Movie
     attr_accessor :title, :plot, :director, :genre, :rt_rating, :rt_url, :cast,
                   :imdb_rating, :imdb_url, :metacritic_rating, :metacritic_url,
                   :release_date, :poster, :rt_id, :imdb_id, :reviews
 
-    def initialize(movie_params)
-
-      @title = movie_params['title']
-      @plot = movie_params['synopsis']
-      @director = movie_params['abridged_directors'][0]['name']
-      @genre = movie_params['genres'][0]
-      @rt_rating = movie_params['ratings']['critics_score']
-      @rt_url = movie_params['links']['alternate']
-      @cast = build_cast_list(movie_params['abridged_cast'])
-      @imdb_id = movie_params['alternate_ids']['imdb']
-      @imdb_url = "http://www.imdb.com/title/tt#{imdb_id}/"
-      @release_date = Date.parse(movie_params['release_dates']['theater'])
-      @rt_id = movie_params['id'].to_s
+    def initialize(movie_args)
+      @title = movie_args[:title]
+      @plot = movie_args[:plot]
+      @director = movie_args[:director]
+      @genre = movie_args[:genre]
+      @rt_rating = movie_args[:rt_rating]
+      @rt_url = movie_args[:rt_url]
+      @cast = movie_args[:cast]
+      @imdb_id = movie_args[:imdb_id]
+      @imdb_url = movie_args[:imdb_url]
+      @release_date = movie_args[:release_date]
+      @rt_id = movie_args[:rt_id]
 
       @imdb_rating = "Not retrieved"
       @metacritic_rating = "Not retrieved"
@@ -29,26 +26,14 @@ module WorthWatching
     # @return [String] the summary
     def summary
       divider = "-" * 60
-      "#{divider}\n#{@title}\n#{divider}\nReleased: #{@release_date.strftime("%d %b %Y")}\n#{divider}\n#{plot}\n#{divider}\nCast: #{@cast}\n#{divider}\n#{rating_summary}\n"
+      "#{divider}\n#{title}\n#{divider}\nReleased: " +
+      "#{release_date.strftime("%d %b %Y")}\n#{divider}\n#{plot}\n#{divider}" +
+      "\nCast: #{cast}\n#{divider}\n#{rating_summary}\n"
     end
 
     def rating_summary
-      "Rotten Tomatoes rating: #{rt_rating}\nIMDB rating: #{imdb_rating}\nMetacritic rating: #{metacritic_rating}\n"
-    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 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/, "")
+      "Rotten Tomatoes rating: #{rt_rating}\nIMDB rating: #{imdb_rating}\n" +
+      "Metacritic rating: #{metacritic_rating}\n"
     end
   end
 end