ratr 0.2.0 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTJjODU4ZWJjMTU5MmVlMzEyOGNkMDY1MDA1NThlODM4MjhlNzNkYw==
+    ZTcyMWMwNDQwMzZlMjVkYTQyM2UxYWNlNzE2ZTNkNTczYTZkMmIxMA==
   data.tar.gz: !binary |-
-    ZDIyZWMzZGMwNzc5NDk4YjY4NWRlNWQ2M2U0Yzk1YjU2NGJmM2Q3NA==
+    ZjJiOThiYzQxNTU4NDkyMmQ5MGVkMjkwMDQxNGM2YjQ4ZmI5OTIwMQ==
 SHA512:
   metadata.gz: !binary |-
-    Y2FmMDVlOTJmYTc1ZjViNDJiMTcwNjY2NGYwYWYwZDdhYjc0ZDk2MGFlNDdj
-    Y2Q5OTg1MjU1NjU4Y2YwZWZkMWNkMjBjODkzYjhjZjI4NmVlNDQ3YzZkN2U2
-    ZTAwYjk2YTg3NjJjMGMzNmNhNWRlZDQ3NDkzZTZlZGQ0YmNhYTY=
+    Yzc0ZTkwOTVjOGMxZDQxZDBlZjY0ODBkYzM3YmFmNWY5MWFlZGY1NmRiODI1
+    MjI2MGNmNzNlNmVhYzRlNjIzNDQ5NjM0MmM0NzkyYTMzYmM2M2EzMGNhNzA2
+    YTljMzZjYmRjMjQxZjdlODc2ODdiYWFjMmMwNWE2Y2I5OGMzNDU=
   data.tar.gz: !binary |-
-    ZDM3YzRlNGMyODQwNmZiMjAxZjljYWNjNzhkYzkwMzE1NjcwMWJlZWEzNTAz
-    NTdmMWRjOTkwZDM0OTYwMjE4NTY4MWNhYmJmM2RlYmEzODRmOWZkN2Y3ZmNi
-    NjY1M2UyZmZlZmFhZTU5NDkzYTQ5M2I3NzQ5ZTJjZDk4MjliNTI=
+    MTUzZTA3Y2VlZmY0ZmU0ZTkwNDFhOGIyODY5ZjhkMDI4OWFmNDdhZjE3YTcw
+    MWFhMzY5YzgzZWZjNTM2MzIyYmI5MGJlOTc4NmMzYmQxOGM5NmNkNGI2ZTlk
+    YmIzNDNjYjhjZThkZjhmMmQzZjhiNzlmMjYyNzUyMDFkNzg5Yjc=

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ratr (0.2.0)
+    ratr (1.0.0)
       faraday (~> 0.9)
       faraday_middleware (~> 0.9)
       typhoeus (~> 0.7)
@@ -9,6 +9,10 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    addressable (2.3.6)
+    crack (0.4.2)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
     ethon (0.7.3)
       ffi (>= 1.3.0)
     faraday (0.9.1)
@@ -17,11 +21,32 @@ GEM
       faraday (>= 0.7.4, < 0.10)
     ffi (1.9.8)
     multipart-post (2.0.0)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    safe_yaml (1.0.4)
     typhoeus (0.7.1)
       ethon (>= 0.7.1)
+    vcr (2.9.3)
+    webmock (1.11.0)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   ratr!
+  rspec (~> 3.1)
+  vcr (~> 2.9)
+  webmock (~> 1.11)

data/README.md

@@ -12,39 +12,108 @@ USAGE
 gem install ratr
 ratr
 
-20 Feet from Stardom 2013  99 82 9.05
-12 Years a Slave 2013 8.1 96 90 8.9
-7th Heaven 1927 7.9 100 87 8.866666666666665
-7 Faces of Dr. Lao 1964 7.3 100 78 8.366666666666667
-8 Mile 2002 6.9 76 54 6.633333333333333
+20 Feet from Stardom (2013): 9.1
+12 Years a Slave (2013): 8.9
+7th Heaven (1927): 8.0
+7 Faces of Dr. Lao (1964): 8.4
+8 Mile (2002): 6.6
 ```
 
-TODOs
------
+DEVELOPMENT
+-----------
+To run the test suite:
+
+```sh
+git clone git@github.com:patricksrobertson/ratr.git
+cd ratr
+bundle
+
+rspec
+```
+
+To throw out the existing VCR cassettes:
+
+```sh
+rm -rf spec/vcr
+rspec
+```
+
+(note the VCR cassette doesn't seem to retry quite as well as the real code,
+so there may be non-deterministic failures as a result of the recording. I
+suggest for the sake of this example that you keep the cassettes)
+
+PERFORMANCE
+-----------
+
+The application should run within the bounds of the Rotten Tomatoes (RT) expected
+response time which I calculate at roughly between 3m45s and 7m50s or so. The
+idea bethind the calculation is that RT actually limits on a per second basis,
+so you can at best case complete 5 requests per second (.2 sec/req) but in a failure
+ridden case you are probably doubling the time on request( .4 sec/req). I'm running
+two parallel requests at a time on the OMDB API, as it tends to respond more slowly
+than the RT API and they are comfortable.
+
+The application pools both sources into independent threads and then blocks until
+both operations are complete. Earlier versions ran this in serial, resulting in 
+unacceptable runtimes.
+
+The way to speed this up would be to have multiple RT API keys, and split the movies
+collection up into N components. Probably not what RT had in mind while doing rate
+limiting.
+
+DURABILITY
+----------
+Neither API particualrly documents the error codes. The only error code I (frequently)
+ran into was a 403 on the RT API -- which should've been a 503 for rate limit exceeded.
+
+The OMDB API scraper handles the 404 case well -- so well that I didn't realize some of
+the movies weren't found on OMDB until I looked at the VCR cassettes. 
+
+Given that I wasn't able to find a maintenance code response from either API -- I deferred
+implementing specific error handling in that event. The last case to consider was timeouts
+on the applications network inoperability, I ran out of time to add that handling in at the end.
+
+I would normally do that.
+
+EXTENSIBILITY
+-------------
+
+The bulk of my effort was devoted to making this slightly more extensible. I constructed a Source
+class that combines an HTTP processor (serial or concurrent) and an HTTP wrapper that tells the source
+how to fetch an individual movie and then scrub the responses down to pertinent scores. The thread manager
+can take N number of sources so in order to add a new source you'd do the following:
+
+* Write HTTP wrapper class, defining the interface of #get, #scrub, #adapter.
+* Add the source (indicating whether it is serial or concurrent) to the Application class
+* Add the source into the sources array passed into the thread manager.
+
+I got a little hand-wavy on my testing of these things. With time allotment light, I aimed for a
+'refactor away a spike' technique where I wrote acceptance tests, then once that was complete
+started moving code around. So on the individual basis the tests are a little light, and I totally
+avoided doubling concrete objects. In order to be able to test with doubles, I'd probably do this:
 
-* Thread management in a real-world example is going to need to be a lil better
-than my off-the-cuff example.
+* Add tests for the specific interfaces/roles (HttpProcessor, HttpWrapper)
+* Share said tests on the concrete examples
+* Feel much more confident about doubling -- now if the interface or a concrete example fails
+the test suite can catch that at the same rate of the implementation.
 
-* handle exceptional errors with approriate measures
-** 500 level responses are probably going to be universal -- should stop activity
+To also be fair, I'm not happy about the HTTP wrappers. The scrub method smells of doing too much.
+I'd look at that with caution and potentially break it out if another source makes this look bad.
 
-* TATFT
+I didn't make the movies collection a real object -- there are some smells of accessing the movies
+collection like a data structure instead of sending messages to it. Making something that implements
+Enumerable would've been preferrable (in addition to doing find methods). The same can be said for
+the collection of results that the Manager returns.
 
-* Make this OO instead of proceedural
+TIME SPENT
+----------
 
-My personal notes:
-* One API source can have multiple ratings (ie rotten tomatoes has two scores).
-* An individual rating source seems to have two to three important dimensions.
-** Scalar (how to get this to a ten point scale)
-** N/A (stored as nil, N/A, -1)
-** Weight -- should I apply the same weight to audience ratings as critic ratings?
+Spike 1 (serial access) [branch pr-spike] - 45 minutes. Goal was to gain understanding of APIs, 
+worst case runtime.
 
-* From best case to worst case in terms of RT runtime: 3.7 - 7.7 minutes (.2 sec per req
-to doubling request time due to timeouts at .4 seconds per req). This solution
-actually runs fairly comfortably in that timeframe. From what I can tell, it looks like
-RT may have a short lived cache, where those hits don't count against your rate limit. Makes
-subsequent runs faster if done quickly after first.
-* For the sake of this exercise, I think client side caching of the requests is probably 
-a no-no in terms of runtime, but will need to be captured on the testing end to avoid
-quickly hitting my request limit on RT's API.
+Spike 2 (parallel access) [branch pr-multi_spike] - 1 hour. Goal was to bring runtime down to
+the time it takes to pull results from the RT API.
 
+Production implementation [master / pr-refactor_from_spike] - 3-4 hours. I dabbled in this throughout
+an evening and did a little work the following morning. Goal was to write tests that could re-run without
+hitting the APIs (rate limit rules everything around me) and bring the required application into an MVP.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/ratr

@@ -1,113 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'csv'
-require 'ostruct'
-require 'faraday'
-require 'faraday_middleware'
-require 'typhoeus'
-require 'typhoeus/adapters/faraday'
+require 'ratr'
 
-# RT is really the problem child when it comes to requesting
-# multiple searches at once. It will return a 403 (forbidden)
-# code on rate limit exceeded which is a pain in the bum.
-#
-# Faraday has ERR::Timeout retries built in, but this is
-# unfortunatley not able to tap into it. The best I can do
-# is to roll my own custom retry mechanism. The idea is
-# to try and retry sooner than the 0.02 under most circumstances.
-def tomato_request(movie, http)
-  retry_count = 3
-  http.get do |request|
-    request.url '/api/public/v1.0/movies.json'
-    request.params['q'] = "#{movie.title} #{movie.year}"
-    request.params['apikey'] = "ww8qgxbhjbqudvupbr8sqd7x"
-    request.params['page_limit'] = 1
-  end
-rescue Faraday::Error::ClientError
-  case retry_count
-  when 3
-    sleep 0.05
-  when 2
-    sleep 0.1
-  when 1
-    sleep 0.2
-  end
 
-  retry_count -=1
-  retry
-end
-
-# read incoming csv file
-movies = []
-CSV.foreach("examples/movies_small.csv") do |row|
-  #assign each movie a title and year. Note: year is not guaranteed
-  movies << OpenStruct.new(title: row[0], year: row[1])
-end
-
-manager = Typhoeus::Hydra.new(max_concurrency: 2)
-omdb = Faraday.new(url: 'http://www.omdbapi.com') do |faraday|
-  faraday.request  :json             # form-encode POST params
-  faraday.response :json                  # log requests to STDOUT
-  faraday.adapter  :typhoeus  # make requests with Net::HTTP
-end
-
-tomatoes = Faraday.new(url: 'http://api.rottentomatoes.com') do |faraday|
-  faraday.request :json
-  faraday.response :json
-  faraday.response :raise_error
-  faraday.adapter  :typhoeus
-end
-
-# Fork a thread out for the OMDB requests
-omdb_responses = {}
-t1 = Thread.new {
-  omdb.in_parallel(manager) do
-    movies.each_with_index do |movie, index|
-      omdb_responses[index] = omdb.get do |request|
-        request.url '/'
-        request.params['t'] = movie.title
-        request.params['y'] = movie.year
-      end
-    end
-  end
-  omdb_responses
-}
-
-# Fork out a thread for RT requests
-tomato_responses = {}
-t2 = Thread.new {
-  movies.each_with_index do |movie, index|
-    tomato_responses[index] = tomato_request(movie, tomatoes)
-  end
-}
-
-# block until the threads are complete
-t1.join
-t2.join
-
-movies.each_with_index do |movie, index|
-  movie.imdb_rating = omdb_responses[index].body['imdbRating']
-  tomato_ratings = tomato_responses[index].body["movies"][0] && tomato_responses[index].body["movies"][0]["ratings"]
-
-  if tomato_ratings
-    movie.tomatoes_critic_rating = tomato_ratings["critics_score"]
-    movie.tomatoes_audience_rating = tomato_ratings["audience_score"]
-  end
-
-  scores = []
-  scores << movie.imdb_rating.to_f unless movie.imdb_rating == nil || movie.imdb_rate == 'N/A'
-  scores << (movie.tomatoes_critic_rating.to_f / 10.0) unless movie.tomatoes_critic_rating == nil || movie.tomatoes_critic_rating == '-1'
-  scores << (movie.tomatoes_audience_rating.to_f / 10.0) unless movie.tomatoes_audience_rating == nil || movie.tomatoes_audience_rating == '-1'
-
-  if scores.size > 0
-    movie.average = scores.reduce(0) {|m,v| m+=v} / scores.size if scores.size > 0
-  else
-    movie.average = 0
-  end
-end
-
-
-# sort the movies collection by average rating -- then display.
-movies.sort {|a,b| b.average <=> a.average}.each do |movie|
-  puts "#{movie.title} (#{movie.year}): #{movie.average}"
-end
+puts Ratr::Application.new("examples/movies.csv").call

data/examples/movies_small.csv

@@ -3,23 +3,3 @@
 8 Mile,2002
 12 Years a Slave,2013
 20 Feet from Stardom,2013
-2001: A Space Odyssey,1968
-20000 Leagues Under the Sea,1954
-The Abyss,1989
-The Accidental Tourist,1988
-The Accountant,2001
-The Accused,1988
-Adaptation,2002
-Adventures of Don Juan,1948
-"The Adventures of Priscilla, Queen of the Desert",1994
-The Adventures of Robin Hood,1938
-Affliction,1997
-The African Queen,1951
-The Age of Innocence,1993
-Air Force,1943
-Airport,1970
-Aladdin,1992
-The Alamo,1960
-The Alaskan Eskimo,1953
-Albert Schweitzer,1957
-Alexander's Ragtime Band,1938

data/lib/ratr.rb

@@ -0,0 +1,12 @@
+module Ratr
+  autoload :Application, 'ratr/application'
+  autoload :ParallelHttpProcessor, 'ratr/parallel_http_processor'
+  autoload :SerialHttpProcessor, 'ratr/serial_http_processor'
+  autoload :OmdbHttpWrapper, 'ratr/omdb_http_wrapper'
+  autoload :RottenTomatoesHttpWrapper, 'ratr/rotten_tomatoes_http_wrapper'
+  autoload :Source, 'ratr/source'
+  autoload :PoolManager, 'ratr/pool_manager'
+  autoload :ArrayOfHashes, 'ratr/utils/array_of_hashes'
+  autoload :AverageCalculator, 'ratr/utils/average_calculator'
+  autoload :MetaRating, 'ratr/meta_rating'
+end

data/lib/ratr/application.rb

@@ -0,0 +1,58 @@
+require 'csv'
+require 'ostruct'
+require 'faraday'
+require 'faraday_middleware'
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
+
+module Ratr
+  class Application
+    attr_reader :file
+    def initialize(file = "examples/movies_small.csv")
+      @file = file
+    end
+
+    def call
+      # read incoming csv file
+      movies = {}
+      movie_key = 0
+      CSV.foreach(file) do |row|
+        #assign each movie a title and year. Note: year is not guaranteed
+        movies[movie_key] = OpenStruct.new(title: row[0], year: row[1])
+        movie_key += 1
+      end
+
+      manager = Ratr::PoolManager.new(sources)
+      manager.process(movies)
+      manager.join
+
+      movies.each do |index, movie|
+        scores = manager.merged_results[index].compact
+
+        movie.average = Ratr::AverageCalculator.call(scores)
+      end
+
+      # sort the movies collection by average rating -- then display.
+      output = []
+      movies.values.sort {|a,b| b.average <=> a.average}.each do |movie|
+        output << "#{movie.title} (#{movie.year}): #{movie.average}"
+      end
+      
+      return output
+    end
+
+    private
+
+    def sources
+      @sources ||= [omdb, rotten_tomatoes]
+    end
+
+    def omdb
+      @omdb ||= Ratr::Source.new(Ratr::ParallelHttpProcessor, Ratr::OmdbHttpWrapper.new)
+    end
+
+    def rotten_tomatoes
+      @rotten_tomatoes = Ratr::Source.new(Ratr::SerialHttpProcessor, Ratr::RottenTomatoesHttpWrapper.new)
+    end
+  end
+end

data/lib/ratr/meta_rating.rb

@@ -0,0 +1,26 @@
+module Ratr
+  class MetaRating
+    include Comparable
+
+    attr_reader :score, :no_score
+    def initialize(score, no_score = 'pity party')
+      @score, @no_score = score, no_score
+    end
+
+    def <=>(other)
+      return -1 if self.not_comparable?
+      return 1 if other.not_comparable?
+
+      self.score <=> other.score
+    end
+
+    def to_s
+      score.to_s
+    end
+
+    protected
+    def not_comparable?
+      score == no_score
+    end
+  end
+end