worth_watching 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e35fd2e5e42565ad5098cfba862e9416a45201d1
-  data.tar.gz: d6bb20f5f5d8ce4b1a2282057c1e937df33930cc
+  metadata.gz: 048abc5a75b5f585a50481cab76c699ec622a4a6
+  data.tar.gz: 7ed6a1134722d026b11ee25d54db2338a7c19e1a
 SHA512:
-  metadata.gz: 67b77513e14d79377de17e6538500ca0f9d8061afdc975f4912f6f5474f185aa448ff5b803c9870b7b73f0a91529f59c7466cbed15a8abf965d52a178a1c83f9
-  data.tar.gz: 185fd25dbff8bc88d45a93aa8b082c53d299daf9d564d2a0ddcbfc2ef0839562e922d9765aeec8d0e373ab3063eaccb0cf2a7b0b2359ebdd451ddcef62a71393
+  metadata.gz: 5903062650b35280dd7373b4ea9c8079936809ca8f554f92282599eac15dd8db00d20108021123c634fd8f14cd0b99432de91e42d0455b9f364fb7ffcba8ef09
+  data.tar.gz: 983f743ff6b0dd3e0ad3b640ea09c7874fca898305d3356b18249419e06f6d9eb2509566a4db123239e28725300d3fa9a5560ecdb95c4cdf4784100c6c73e679

data/.gitignore

@@ -16,4 +16,6 @@ test/tmp
 test/version_tmp
 tmp
 config/config.yml
-spec/vcr_cassettes/
+spec/vcr_cassettes/
+todo.txt
+config.yaml

data/README.md

@@ -1,9 +1,43 @@
-# WorthWatching
+## WorthWatching
 
-WorthWatching is a gem that allows you to aggregate movie review data from a 
+WorthWatching is a gem that aggregates movie review data from a
 number of different sources.
 
-Current supported sources are Rotten Tomatoes, IMDb and Metacritic.
+Currently, the supported info sources are [Rotten Tomatoes](http://rottentomatoes.com), [IMDb](http://imdb.com) and [Metacritic](http://metacritic.com).
+
+### What info does WorthWatching aggregate?
+
+The gem was designed to retrieve the overall rating form each source. But it also
+retrieves extra info that may be useful.
+
+The full list of info retrieved for each movie:
+
+- title
+- plot (no spoilers, just the general description)
+- director
+- cast
+- genre
+- release date
+- **Rotten Tomatoes rating (n out of 100)**
+- **IMDb rating (n out of 10)**
+- **Metacritic rating (n out of 100)**
+- Rotten Tomatoes movie URL
+- IMDb movie URL
+- Metacritic movie URL
+- Rotten Tomaotes movie ID
+- IMDb movie ID
+- poster image URL
+- reviews
+
+Note that the success of the aggregation process is entirely dependent on knowing
+the Rotten Tomatoes ID *first*.
+
+However, you can use the `search_by_title` method to first search for a movie.
+The search results include the Rotten Tomatoes ID, which you can then use aggregate movie info as
+usual with the `aggregate_movie` method.
+
+If you would like to know why this is the case, or are just interested in how aggregation happens,
+[read here]() for some extra information.
 
 ## Installation
 
@@ -21,52 +55,223 @@ Or install it yourself as:
 
 ## Setup
 
-* Apply for the required API keys. You will need a [Rotten Tomatoes API Key](http://developer.rottentomatoes.com/)  and a [TMDB API key](http://docs.themoviedb.apiary.io/).
+- Apply for the required API keys. You will need a [Rotten Tomatoes API Key](http://developer.rottentomatoes.com/)  and a [TMDB API key](http://docs.themoviedb.apiary.io/).
 
-* Fill in the details of your API keys in config/config.yml
 
 ## Usage
 
+### Getting started
+```ruby
+# Create a new aggregator, passing in your API keys
+movie_aggregator = WorthWatching::Aggregator.new("rotten_tomato_api_key", "tmdb_api_key")
+```
+
+### Searching for a movie by title
+
+Pass the title of the movie, and the maximum number of results to return
+
+```ruby
+# 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)
+=> [{: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"},
+{:title=>"The Godfather of Green Bay", :rt_id=>"341816359", :year=>"2005"}]
+```
+
+### Retrieving info for a single movie
 ```ruby
-# Create a new aggregator
-movie_aggregator = WorthWatching::Aggregator.new("rotten_tomatoes_api_key", "tmdb_api_key")
 
-# Search for movie by Rotten Tomatoes ID
-toy_story_3 = movie_aggregator.movie_info('770672122')
+# Pass the movie's Rotten Tomatoes ID
+toy_story_3 = movie_aggregator.aggregate_movie("770672122")
 
-# We now have a Movie object and can access many attributes, including rating information
-toy_story_3.title 
+# We now have a Movie object and can access many attributes...
+toy_story_3.title
 => "Toy Story 3"
+```
 
+### Rating Info
+```ruby
+# Access ratings individually
 toy_story_3.rt_rating
 => 99
 
 toy_story_3.imdb_rating
-=> 85
+=> 8.5
 
 toy_story_3.metacritic_rating
 => 92
 
+# Get the rating summary as a string
+puts toy_story_3.rating_summary
+=> "Rotten Tomatoes rating: 99
+IMDB rating: 8.5
+Metacritic rating: 92"
+```
+### General movie info
+```ruby
+toy_story_3.plot
+=> "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"
+
+toy_story_3.director
+=> "Lee Unkrich"
+
+toy_story_3.cast
+=> "Tom Hanks, Tim Allen, Joan Cusack, Ned Beatty"
+
+toy_story_3.genre
+=> "Animation"
+
+toy_story_3.release_date
+=> #<Date: 2010-06-18 ((2455366j,0s,0n),+0s,2299161j)>
+
+# Rotten Tomatoes URL
+toy_story_3.rt_url
+=> "http://www.rottentomatoes.com/m/toy_story_3/"
+
+toy_story_3.imdb_url
+=> "http://www.imdb.com/title/tt0435761/"
+
+toy_story_3.metacritic_url
+=> "http://www.metacritic.com/movie/toy-story-3"
+
+# Rotten Tomatoes ID
+toy_story_3.rt_id
+=> "770672122"
+
+toy_story_3.imdb_id
+=> "0435761"
+
+toy_story_3.poster
+=> "http://cf2.imgobject.com/t/p/original/tOwAAVeL1p3ls9dhOBo45ElodU3.jpg"
 
-# Get a short 5-film list of movies currently on release 
-recent_movies = movie_aggregator.in_cinemas(5)
+# Get a general summary
+puts toy_story_3.summary
+=> "Toy Story 3
+------------------------------------------------------------
+Released: 18 Jun 2010
+------------------------------------------------------------
+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
+------------------------------------------------------------
+Cast: Tom Hanks, Tim Allen, Joan Cusack, Ned Beatty
+------------------------------------------------------------
+Rotten Tomatoes rating: 99
+IMDB rating: 8.5
+Metacritic rating: 92"
+```
+
+### Movie reviews
+Sourced from Rotten Tomatoes. ``Movie`` object has an instance variable ``reviews``,
+which is an array of ``WrittenReview`` objects.
+
+```ruby
+# Get the first review
+a_review = toy_story_3.reviews.last
+a_review.author
+=> "Ailsa Caine"
+
+a_review.date
+=> #<Date: 2010-07-22 ((2455400j,0s,0n),+0s,2299161j)>
+
+a_review.quote
+=> "By [Pixar's] high standards this isn't the best, but by anyone else's, it's close to perfection."
+
+# Reviews are those collated by Rotten Tomatoes, where the review scale is binary ("fresh" or "rotten")
+a_review.rating
+=> "fresh"
+
+# The review's original score (not always available)
+a_review.original_score
+=> "4/5"
 
-iron_man = recent_movies.first
+a_review.source
+=> "Little White Lies"
 
-iron_man.title
-=> "Iron Man 3"
+a_review.link
+=> "http://www.littlewhitelies.co.uk/theatrical-reviews/toy-story-3/"
 
-critic_review = iron_man.reviews.first
-critic_review.quote
-=> "The trouble is that, as the plot quickens, any cleverness withdraws, to make 
-    way for the firecrackers of the climax. That is not Black's forte, and his 
-    movie duly slumps into a mess."
+# Convenience method to summarise the review as a string
+a_review.to_s
+=> "Ailsa Caine wrote on 2010-07-22 : By [Pixar's] high standards this isn't the best, but by anyone else's, it's close to perfection.
+Rating: 4/5"
 ```
 
-## Contributing
+### 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.
+
+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),
+and finally, the maximum number of movies on the list you are interested in.
+
+The available lists mirror those available through the Rotten Tomatoes API.
+
+They are:
+
+- ``:box_office`` - top box office earning movies, sorted by most recent weekend gross
+ticket sales
+- ``:in_theaters`` - movies currently in theaters/cinemas
+- ``:opening`` - current opening movies in the theaters/cinema
+- ``:upcoming`` - upcoming movies in theaters/cinema
+- ``:top_rentals`` - top DVD rentals
+- ``:current_releases`` - current DVD releases
+- ``: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
+
+# Aggregate the top 4 box office movies in the UK
+top_movies = movie_aggregator.aggregate_list(:box_office, :uk, 4)
+
+# Or the top 6 releases on DVD in the US
+top_dvds = movie_aggregator.aggregate_list(:top_rentals, :us, 6)
+
+# The above list-based methods return an array of Movie objects
+number_1_movie = top_movies.first
+
+number_1_movie.title
+=> "Captain America: The Winter Soldier"
+
+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.
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+The opposite is true for lists like ``:box_office`` and ``top_rentals``.

data/lib/worth_watching/aggregator.rb

@@ -1,11 +1,13 @@
-require 'httparty'
 require 'nokogiri'
 require 'open-uri'
+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'
@@ -17,152 +19,129 @@ module WorthWatching
     end
 
     # Retrieve the details of a specific movie using its IMDB ID
+    #
     # @param rt_id [String] the Rotten Tomatoes ID of the movie
     # @return [Movie] a Movie object representing the movie
-    def movie_info(rt_id)
-      uri = "#{RT_API_BASE_URL}/movies/#{rt_id}.json?apikey=#{rt_api_key}"
-      movie_hash = HTTParty.get(uri)
+    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)
 
-      aggregate(Movie.new(movie_hash))
+      @movie = Movie.new(movie_hash)
+      aggregate
     end
 
-    # Retrieve a list of movies that are currently in cinemas
-    # @param result_limit [Integer] the maximum number of results to return
-    # @return [Array] an Array of Movie objects
-    def in_cinemas(result_limit, type)
-
-      case type
-        when :cinema
-          uri = "#{RT_API_BASE_URL}/lists/movies/in_theaters.json?page_limit=#{result_limit}"\
-                "&page=1&country=uk&apikey=#{rt_api_key}"
-        when :dvd
-          uri = "#{RT_API_BASE_URL}/lists/dvds/top_rentals.json?page_limit=#{result_limit}"\
-                "&page=1&country=uk&apikey=#{rt_api_key}"
+    # 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
 
-      movie_list = HTTParty.get(uri)
-      movie_list = movie_list["movies"]
-      in_theaters = []
-
-      movie_list.each do |movie|
-        if enough_info?(movie)
-          movie = movie_info(movie['id'])
-          in_theaters << movie
-        end
-      end
-      Aggregator.clean_up(in_theaters)
-      return in_theaters
+      get_movie_list(uri)
     end
 
-    # Aggregates exta information about a movie that cannot be derived directly from the
-    # Rotten Tomatoes API e.g IMDb/Metacritic rating, HQ posters
-    # @param movie [Movie] the movie to aggregate information for
-    # @return [Movie] the movie passed in with aggregated info completed
-    def aggregate(movie)
-      extra_info = get_extra_info_via_omdb(movie.imdb_id)
+    # 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}"
 
-      movie.imdb_rating = extra_info[:imdb_rating]
-      movie.metacritic_rating = extra_info[:metacritic_rating]
-      movie.metacritic_url = extra_info[:metacritic_url]
+      response = JSON.parse(Typhoeus.get(uri).body)
 
-      movie.poster = get_poster(movie.imdb_id)
-      movie.reviews = get_reviews(movie.rt_id)
-
-      return movie
+      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
 
-    # Retrieves extra info about a particular movie that cannot be found using
-    # the Rotten Tomatoes API. All facilitated by its IMDb ID.
-    # @params imdb_id [String] the IMDb ID of the required movie (without 'tt' prefixed)
-    # @return [Hash] a hash containing IMDb rating, Metacritic rating and movie URL
-    def get_extra_info(imdb_id)
-      imdb_url = "http://m.imdb.com/title/tt#{imdb_id}"
-
-      imdb_page = Nokogiri::HTML(open(imdb_url))
-      extra_info = {}
-
-      # Extract IMDB rating
-      extra_info[:imdb_rating] = imdb_page.css('.votes strong').text
-
-      # Extract Metacritic rating (IMDB has a page listing MC reviews)
-      imdb_mc_page = Nokogiri::HTML(open("http://www.imdb.com/title/tt#{imdb_id}/criticreviews"))
-
-      mc_rating = imdb_mc_page.css(".metascore > span").text
-
-      if mc_rating != ""
-        extra_info[:metacritic_rating] = mc_rating
-        extra_info[:metacritic_url] = imdb_mc_page.css(".see-more .offsite-link")[0]["href"]
-      else
-        extra_info[:metacritic_rating] = "No Rating"
-        extra_info[:metacritic_url] = "No URL"
-      end
-
-      return extra_info
+    # 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
 
-    def get_extra_info_via_omdb(imdb_id)
-      extra_info = {}
-      omdb_response = HTTParty.get("http://www.omdbapi.com/?i=tt#{imdb_id}")
+    # 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"
-        imdb_rating = omdb_response["imdbRating"]
-        movie_title = omdb_response["Title"]
-
-        mc_info = scrape_metacritic_info(movie_title)
-
-        mc_rating = mc_info[:mc_rating]
-        mc_link = mc_info[:mc_url]
-      else
-        imdb_rating = "Unavailable"
-      end
-
-      # Extract IMDB rating
-      extra_info[:imdb_rating] = imdb_rating
-
-      if mc_rating != ""
-        extra_info[:metacritic_rating] = mc_rating
-        extra_info[:metacritic_url] = mc_link
+        @movie.imdb_rating = omdb_response["imdbRating"]
       else
-        extra_info[:metacritic_rating] = "Unavailable"
-        extra_info[:metacritic_url] = "No URL"
+        @movie.imdb_rating = "Unavailable"
       end
-
-      return extra_info
     end
 
-    # Scrapes the metacritic rating and URL, returning a hash containing the info
-    def scrape_metacritic_info(movie_title)
-      mc_info = {}
+    # Retrieves and updates the current movie's Metacritic rating and URL
+    def retrieve_metacritic_info
+      metacritic_page = Nokogiri::HTML(open("http://www.metacritic.com/search/"\
+                        "movie/#{CGI.escape(@movie.title)}/results"))
 
-      # Extract Metacritic rating (IMDB has a page listing MC reviews)
-        metacritic_page = Nokogiri::HTML(open("http://www.metacritic.com/search/"\
-                          "movie/#{CGI.escape(movie_title)}/results"))
-        mc_info[:mc_rating] = metacritic_page.css('.first_result .metascore_w').text
-        mc_info[:mc_url] = "http://www.metacritic.com#{metacritic_page.at_css('.first_result a').attr(:href)}"
+      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)}"
 
-        return mc_info
+      # 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
 
-    # Retrieves the URL of a high resolution poster of a movie
-    # @params imdb_id [String] the IMDb ID of the required movie (without 'tt' prefixed)
-    # @return [String] the URL of the poster as a string
-    def get_poster(imdb_id)
-      uri = "#{TMDB_API_BASE_URL}/movie/tt#{imdb_id}?api_key=#{tmdb_api_key}"
-      movie_info = HTTParty.get(uri, :headers => { 'Accept' => 'application/json'})
+    # 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")
-        "http://cf2.imgobject.com/t/p/original" + movie_info["poster_path"]
+        @movie.poster = "http://cf2.imgobject.com/t/p/original" + movie_info["poster_path"]
       else
-        "No poster available"
+        @movie.poster = "No poster available"
       end
     end
 
-    def get_reviews(rt_id)
-      uri = "#{RT_API_BASE_URL}/movies/#{rt_id}/reviews.json?review_type=top_critic"\
-            "&page_limit=5&page=1&country=uk&apikey=#{rt_api_key}"
-      review_hash = HTTParty.get(uri)
+    # 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 = []
 
@@ -170,11 +149,12 @@ module WorthWatching
         review_list << WrittenReview.new(review)
       end
 
-      return review_list
+      @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)
@@ -197,13 +177,21 @@ module WorthWatching
       return has_release_date && has_imdb_id
     end
 
-    # Removes movies from an array that do no have the required rating information
-    # @param movie_list [Array] the list to clean up
-    # @return [Array] the pruned list of movies
-    def self.clean_up(movie_list)
-      movie_list.delete_if do |movie|
-        movie.metacritic_rating == "No Rating"
-     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_list = movie_list_response.inject([]) do |list, movie|
+        list << aggregate_movie(movie['id']) if enough_info?(movie)
+        list
+      end
+
+      return movie_list
     end
   end
 end