flix4r 0.2.3

data/lib/net_flix/movie.rb

@@ -0,0 +1,10 @@
+module NetFlix
+  class Movie < Title
+
+    protected
+    # the nodes that correspond to the constructor argument
+    def self.node_xpath
+      "//catalog_title[contains(id/text(),'movies')]"
+    end
+  end
+end

data/lib/net_flix/request.rb

@@ -0,0 +1,82 @@
+module NetFlix
+  class Request < Valuable
+
+    RESERVED_CHARACTERS = /[^A-Za-z0-9\-\._~]/
+
+    has_value :http_method, :default => 'GET'
+    has_value :url, :default => 'http://api.netflix.com/catalog/titles/index'
+    has_value :parameters, :klass => HashWithIndifferentAccess, :default => {}
+    has_value :cache_options, :default => {}
+    
+    def self.default_cache_options
+      {
+        :cache => 600,    # 10 minutes  After this time fetch new data
+        :valid => 86400,  # 1 day       Maximum time to use old data
+                          #             :forever is a valid option
+        :period => 60,    # 1 minute    Maximum frequency to call API
+        :timeout => 5     # 5 seconds   API response timeout
+      }
+    end
+    
+
+    def ordered_keys
+      parameters.keys.sort
+    end
+    def parameter_string
+      ordered_keys.map do |key, value|
+        "#{key}=#{ ( key == 'term' )? URI.escape( parameters[key] ) : parameters[key]}"
+      end.join('&')
+    end
+
+    def authenticator
+      @auth ||= NetFlix::Authenticator.new(:request => self, :credentials => NetFlix.credentials)
+    end
+
+    def target
+      URI.parse "#{url}?#{parameter_string}"
+    end
+
+    def log
+      NetFlix.log(target.to_s)
+    end
+
+    def send
+      merged_cache_options = self.class.default_cache_options.merge(cache_options)
+      APICache.get(target.to_s, merged_cache_options ) do
+        authenticator.sign!
+        log
+        Net::HTTP.get(target)
+      end
+    end
+
+    def write_to_file(file_name)
+      authenticator.sign!
+      Net::HTTP.start(target.host, target.port) do |http|
+        File.open( file_name, 'w') do |file|
+          http.request_get(target.request_uri) do |response|
+            response.read_body do |body|
+              file.write(body)
+            end
+          end
+        end
+      end
+    end
+
+    def self.encode(value)
+      URI.escape( value.to_s, RESERVED_CHARACTERS ) if value
+    end
+
+    # validation stuff
+    has_collection :errors
+
+    def valid?
+      errors.clear
+      validate_http_method
+      errors.empty?
+    end
+
+    def validate_http_method
+      errors << "HTTP method must be POST or GET, but I got #{http_method}" unless ['POST', 'GET'].include? http_method 
+    end
+  end
+end

data/lib/net_flix/television.rb

@@ -0,0 +1,14 @@
+module NetFlix
+  class Television < Title
+
+    def actors
+      @actors ||= ActorBuilder.from_movie(@xdoc)
+    end
+
+    protected
+    # the nodes that correspond to the constructor argument
+    def self.node_xpath
+      "//catalog_title[not(contains(id/text(),'movies'))]"
+    end
+  end
+end

data/lib/net_flix/title.rb

@@ -0,0 +1,113 @@
+module NetFlix
+  class Title
+    RATING_PREDICATE = %w{ G PG PG-13 R NC-17 NR }.map do |rating| 
+        "@term=\"#{rating}\""
+    end.join(' or ')
+
+    def initialize(xml)
+      @xdoc = xml.is_a?(String) ? Nokogiri.parse( xml ) : xml
+    end
+
+    def actors
+      @actors ||= ActorBuilder.from_movie(@xdoc)
+    end
+
+    # not every title has a director!
+    def directors
+      @directors ||= ( Nokogiri.parse(fetch_link('directors')) / "/people/person/name/text()" ).to_a.map(&:to_s)
+    end
+
+    def rating
+      ( @xdoc / "//catalog_title/category[#{RATING_PREDICATE}]/@term" ).to_s
+    end
+
+    def release_year
+      ( @xdoc / "//catalog_title/release_year/text()" ).to_s
+    end
+
+    # suppported title lengths are :short (the default) and :regular.
+    def title(length=:short)
+      ( @xdoc / "//catalog_title/title/@#{length}" ).to_s
+    end
+
+    def images
+      HashWithIndifferentAccess.new(Crack::XML.parse(@xdoc.xpath('//catalog_title/box_art').to_s)['box_art'])
+    end
+
+    def synopsis
+      @synopsis ||= begin 
+        Crack::XML.parse(fetch_link('synopsis'))['synopsis']
+      rescue
+        ''
+      end
+    end
+
+    def id
+      @id ||= begin 
+        node = @xdoc.search('id').first
+        node.content if node
+      end
+    end
+
+    def movie
+      @movie ||= NetFlix::Movie.new(NetFlix::Request.new(:url => id ).send) if is_movie?
+    end
+
+    def is_movie?
+      id =~ /movies\/(\d+)/
+    end
+
+    def to_s
+      title || 'unknown title'
+    end
+
+    private
+    def fetch_link(title)
+      link_url = ( @xdoc / "//catalog_title/link[@title='#{title}']/@href" ).to_s
+      NetFlix::Request.new(:url => link_url ).send unless link_url.blank?
+    end
+
+    class << self
+      def base_url
+        'http://api.netflix.com/catalog/titles'
+      end
+
+      def autocomplete(params)
+        (Nokogiri.parse(
+          NetFlix::Request.new(:url => base_url << '/autocomplete', :parameters => params).send
+        ) / '//title/@short').to_a.map(&:to_s)
+      end
+
+      def index(file_name)
+        NetFlix::Request.new( :url => NetFlix::Title.base_url + '/index').write_to_file(file_name)
+      end
+
+      def search(params)
+        parse(NetFlix::Request.new(:url => base_url, :parameters => params).send)
+      end
+
+      def find( params )
+        if params[:id]
+          new( NetFlix::Request.new(:url => params[:id]).send )
+        elsif params[:term]
+          search(params)
+        end
+      end
+
+      def parse(xml)
+        return [] unless xml
+
+        nxml = Nokogiri.XML(xml)
+        
+        (nxml / node_xpath).map do |data|
+          self.new(data.to_s)
+        end
+      end
+      protected
+      def node_xpath
+        '//catalog_title'
+      end
+    end
+  end # class Title
+end # module NetFlix
+

data/lib/valuable.rb

@@ -0,0 +1,82 @@
+require 'active_support'
+
+class Valuable
+
+  def attributes
+    @attributes ||= deep_duplicate_of(self.class.defaults)
+  end
+
+  def initialize(atts = {})
+    atts.each { |name, value| __send__("#{name}=", value ) } 
+  end
+
+  def deep_duplicate_of(value)
+    Marshal.load(Marshal.dump(value))
+  end
+
+  class << self
+
+    def attributes
+      @attributes ||= []
+    end 
+
+    def defaults
+      @defaults ||= {}
+    end 
+
+    def has_value(name, options={})
+      attributes << name 
+      defaults[name] = options[:default] unless options[:default].nil?
+      
+      create_accessor_for(name)
+      create_setter_for(name, options[:klass], options[:default])
+    end
+
+    def create_setter_for(name, klass, default)
+        
+      if klass == nil
+        define_method "#{name}=" do |value|
+          attributes[name] = value 
+        end
+
+      elsif klass == Integer
+
+        define_method "#{name}=" do |value|
+          value_as_integer = value && value.to_i
+          attributes[name] = value_as_integer
+        end
+
+      elsif klass == String
+	
+	define_method "#{name}=" do |value|
+          value_as_string = value && value.to_s
+          attributes[name] = value_as_string
+	end
+
+      else
+
+        define_method "#{name}=" do |value|
+          if value.nil?
+            attributes[name] = nil 
+	  elsif value.is_a? klass
+	    attributes[name] = value
+	  else
+	    attributes[name] = klass.new(value)
+	  end
+        end
+      end
+    end
+
+    def create_accessor_for(name)
+      define_method name do
+        attributes[name]
+      end
+    end
+
+    def has_collection(name)
+      has_value(name, :default => [] )
+    end 
+
+  end
+
+end

data/test/actor_builder_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+class ActorBuilderTest < Test::Unit::TestCase
+
+  def test_that_actors_are_parsed
+    xml = %|<title_index_item>  
+                <link href="http://api.netflix.com/catalog/people/98401" rel="http://schemas.netflix.com/catalog/person.actor" title="George Wendt"></link>
+		<link href="http://api.netflix.com/catalog/people/35954" rel="http://schemas.netflix.com/catalog/person.actor" title="Robert Hy Gorman"></link>
+	      </title_index_item>  
+           |
+    data = Nokogiri.XML(xml).search('//.')	 
+    assert_equal ['George Wendt', 'Robert Hy Gorman'], ActorBuilder.from_movie(data).sort
+  end
+
+  def test_that_cast_reference_is_pulled
+
+    NetFlix::Request.expects(:new).with(:url => 'http://api.netflix.com/catalog/titles/movies/60024073/cast').returns(stub_everything(:send => '<xml/>'))
+    
+    xml = %|
+              <title_index_item>  
+                <link href="http://api.netflix.com/catalog/titles/movies/60024073/cast" rel="http://schemas.netflix.com/catalog/people.cast" title="cast"></link>
+	      </title_index_item>  
+           |
+    data = Nokogiri.XML(xml).search('//title_index_item')
+
+    ActorBuilder.from_movie(data)    
+  end
+
+  def test_that_cast_list_is_parsable
+    xml = %|<people><person><id>http://api.netflix.com/catalog/people/20037237</id><name>Vanessa Bell Calloway</name><link href="http://api.netflix.com/catalog/people/20037237/filmography" rel="http://schemas.netflix.com/catalog/titles.filmography" title="filmography"></link><link href="http://www.netflix.com/RoleDisplay/Vanessa_Bell_Calloway/20037237" rel="alternate" title="web page"></link></person></people>|
+
+    assert_equal ['Vanessa Bell Calloway'], ActorBuilder.from_xml(xml)
+  end
+
+end

data/test/authenticator_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+class AuthenticatorTest < Test::Unit::TestCase
+
+  def test_that_url_is_properly_encoded
+    fake_request = stub_everything(:url => 'http://photos.example.net/a pic')
+    assert_equal 'http%3A%2F%2Fphotos.example.net%2Fa%20pic', NetFlix::Authenticator.new(:request => fake_request).encoded_url
+  end
+
+  def test_that_authentication_corresponds_to_known_values
+    #based on http://developer.netflix.com/docs/Security#0_pgfId-1015486
+    #based on http://term.ie/oauth/example/client.php
+
+    cred = stub_everything(
+	     :key => '123456789012345678901234',
+             :secret => '1234567890',
+             :valid? => true)
+    
+    expected_sbs = 'GET&http%3A%2F%2Fapi.netflix.com%2Fcatalog%2Ftitles&max_results%3D5%26oauth_consumer_key%3D123456789012345678901234%26oauth_nonce%3D24aea97b0b5dd516145966aaf2945c6a%26oauth_signature_method%3DHMAC-SHA1%26oauth_timestamp%3D1233950836%26oauth_version%3D1.0%26term%3Dsneakers'
+
+    expected_signature = 'vlROEST9UXwI+zc9fld82giaYPE='
+
+    request = NetFlix::Request.new(
+      :url => 'http://api.netflix.com/catalog/titles',
+      :http_method => 'GET',
+      :parameters => {'term' => 'sneakers', 'max_results' => '5'})
+	    
+    auth = NetFlix::Authenticator.new(
+        :request => request,
+        :timestamp => 1233950836,
+        :nonce => '24aea97b0b5dd516145966aaf2945c6a',
+	:credentials => cred
+      )
+	  
+    assert_equal expected_sbs, auth.signature_base_string
+    assert_equal expected_signature, auth.signature
+  end
+
+  def test_that_signature_key_includes_consumer_secret_and_ampersand
+    cred = stub_everything(:secret => 'shhh', :key => 'letmein')
+    assert_equal 'shhh&', NetFlix::Authenticator.new(:credentials => cred).signature_key
+  end
+
+  def test_that_access_token_is_included_in_signature_key_if_it_is_available
+    cred = stub_everything(:secret => 'shhh', :key => 'letmein', :access_token => 'they_like_me')
+    request = stub_everything
+
+    assert_equal 'shhh&they_like_me', NetFlix::Authenticator.new(:request => request, :credentials => cred).signature_key
+  end
+
+  def test_that_signature_is_added_to_parameters_during_signing
+    cred = stub_everything(:secred => 'shhh', :key => 'letmein', :valid? => true) 
+    params = {}
+    
+    request = stub_everything(:parameters => params)
+    auth = NetFlix::Authenticator.new(:request => request, :credentials => cred)
+    auth.sign!
+    assert params['oauth_signature']
+  end
+
+  def test_that_exception_is_raised_if_secret_is_missing
+    credentials = stub_everything(:valid? => false)
+    authenticator = NetFlix::Authenticator.new(:credentials => credentials)
+
+    assert_raises ArgumentError do
+      authenticator.require_credentials
+    end
+  end
+
+end

data/test/credentials_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class CredentialsTest < Test::Unit::TestCase
+
+  def file_contents
+    {:key => :value}.to_yaml
+  end
+
+  def test_that_credentials_file_is_not_loaded_if_it_dne
+    File.stubs(:exist?).returns(false)
+    File.expects(:open).never
+    NetFlix::Credentials.from_file
+  end
+
+  def test_that_credentials_file_is_loaded_if_present
+    File.stubs(:exist?).returns(true)
+    File.expects(:open).returns(file_contents)
+    NetFlix::Credentials.from_file
+  end
+
+  def test_that_values_from_file_are_present
+    File.stubs(:exist?).returns(true)
+    File.stubs(:open).returns({:key => :my_key, :secret => 'quiet!'}.to_yaml)
+    assert_equal :my_key, NetFlix::Credentials.from_file.key
+  end
+
+end

data/test/fixtures/autocomplete.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" standalone="yes"?>
+
+<autocomplete>
+  <url_template>http://api.netflix.com/catalog/titles/autocomplete?{-join|&amp;|term}</url_template>
+  <autocomplete_item>
+    <title short="Love Wrecked"></title>
+  </autocomplete_item>
+  <autocomplete_item>
+    <title short="Lovesickness"></title>
+  </autocomplete_item>
+  <autocomplete_item>
+    <title short="Loverboy"></title>
+  </autocomplete_item>
+</autocomplete>
+