movie_searcher 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg/*
+*.gem
+.bundle

data/.rspec

@@ -0,0 +1,5 @@
+--color
+-fs
+-Ilib
+-Ispec
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in undertexter.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    MovieSearcher (0.0.1)
+      httparty
+      levenshtein
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    httparty (0.7.3)
+      crack (= 0.1.8)
+    levenshtein (0.2.0)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  MovieSearcher!
+  httparty
+  levenshtein
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jon Maddox
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# ImdbParty!
+
+## How To Use
+
+### Create an instance
+
+    imdb = ImdbParty::Imdb.new
+### Search for a movie by title
+
+    imdb.find_by_title("The Dark Knight") => [{:title => "The Dark Knight", :year => "2008", :imdb_id => "tt0468569"}, {:title => "Batman Unmasked", ...}]
+
+### Get a movie by its imdb_id
+
+    movie = imdb.find_movie_by_id("tt0468569")
+
+    movie.title => "The Dark Knight"
+    movie.rating => 8.1
+    movie.certification => "PG-13"
+
+### Find the top 250 movies of all time
+
+    imdb.top_250 => [{:title => "Shawshank Redemption", :year => "1994", :imdb_id => "tt0111161"}, {:title => "The Godfather", ...}]
+
+### Get the currently popular tv shows
+
+    imdb.popular_shows => [{:title => "Glee", :year => "2009", :imdb_id => "tt1327801"}, {:title => "Dexter", ...}]

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "imdb_party"
+    gem.summary = %Q{IMDB client using the IMDB API that their iPhone app uses}
+    gem.description = %Q{IMDB client using the IMDB API that their iPhone app uses}
+    gem.email = "jon@mustacheinc.com"
+    gem.homepage = "http://github.com/maddox/imdb_party"
+    gem.authors = ["Jon Maddox"]
+    gem.add_development_dependency "shoulda"
+    gem.add_dependency "httparty"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "imdb_party #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/imdb_party.rb

@@ -0,0 +1,8 @@
+require 'httparty'
+
+directory = File.expand_path(File.dirname(__FILE__))
+require File.join(directory, 'imdb_party', 'httparty_icebox')
+require File.join(directory, 'imdb_party', 'imdb')
+require File.join(directory, 'imdb_party', 'movie')
+require File.join(directory, 'imdb_party', 'person')
+

data/lib/imdb_party/httparty_icebox.rb

@@ -0,0 +1,259 @@
+# = Icebox : Caching for HTTParty
+# 
+# Cache responses in HTTParty models [http://github.com/jnunemaker/httparty]
+# 
+# === Usage
+#
+#   class Foo
+#     include HTTParty
+#     include HTTParty::Icebox
+#     cache :store => 'file', :timeout => 600, :location => MY_APP_ROOT.join('tmp', 'cache')
+#   end
+#
+# Modeled after Martyn Loughran's APICache [http://github.com/newbamboo/api_cache]
+# and Ruby On Rails's caching [http://api.rubyonrails.org/classes/ActiveSupport/Cache.html]
+#
+# Author: Karel Minarik [www.karmi.cz]
+# 
+# === Notes
+# 
+# Thanks to Amit Chakradeo to point out objects have to be stored marhalled on FS
+# Thanks to Marlin Forbes to point out query parameters have to be include in the cache key
+# 
+# 
+
+require 'logger'
+require 'fileutils'
+require 'tmpdir'
+require 'pathname'
+require 'digest/md5'
+
+module HTTParty #:nodoc:
+  module Icebox
+
+    module ClassMethods
+
+      # Enable caching and set cache options
+      # Returns memoized cache object
+      #
+      # Following options are available, default values are in []:
+      #
+      # +store+::       Storage mechanism for cached data (memory, filesystem, your own) [memory]
+      # +timeout+::     Cache expiration in seconds [60]
+      # +logger+::      Path to logfile or logger instance [STDOUT]
+      # 
+      # Any additional options are passed to the Cache constructor
+      #
+      # Usage:
+      #
+      #   # Enable caching in HTTParty, in memory, for 1 minute
+      #   cache # Use default values
+      #
+      #   # Enable caching in HTTParty, on filesystem (/tmp), for 10 minutes
+      #   cache :store => 'file', :timeout => 600, :location => '/tmp/'
+      #
+      #   # Use your own cache store (see AbstractStore class below)
+      #   cache :store => 'memcached', :timeout => 600, :server => '192.168.1.1:1001'
+      #
+      def cache(options={})
+        options[:store]   ||= 'memory'
+        options[:timeout] ||= 60
+        logger = options[:logger]
+        @cache ||= Cache.new( options.delete(:store), options )
+      end
+
+    end
+
+    # When included, extend class with +cache+ method
+    # and redefine +get+ method to use cache
+    # 
+    def self.included(receiver) #:nodoc:
+      receiver.extend ClassMethods
+      receiver.class_eval do
+
+        # Get reponse from network
+        # TODO: Why alias :new :old is not working here? Returns NoMethodError
+        # 
+        def self.get_without_caching(path, options={})
+          perform_request Net::HTTP::Get, path, options
+        end
+
+        # Get response from cache, if available
+        # 
+        def self.get_with_caching(path, options={})
+          key = path.clone
+          key << options[:query].to_s if defined? options[:query]
+          
+          if cache.exists?(key) and not cache.stale?(key)
+            Cache.logger.debug "CACHE -- GET #{path}#{options[:query]}"
+            return cache.get(key)
+          else
+            Cache.logger.debug "/!\\ NETWORK -- GET #{path}#{options[:query]}"
+            response = get_without_caching(path, options)
+            cache.set(key, response) if response.code == 200
+            return response
+          end
+        end
+
+        # Redefine original HTTParty +get+ method to use cache
+        # 
+        def self.get(path, options={})
+          self.get_with_caching(path, options)
+        end
+
+      end
+    end
+
+    # === Cache container
+    # 
+    # Pass a store name ('memory', etc) to initializer
+    # 
+    class Cache
+      attr_accessor :store
+
+      def initialize(store, options={})
+        self.class.logger = options[:logger]
+        @store = self.class.lookup_store(store).new(options)
+      end
+
+      def get(key);            @store.get encode(key) unless stale?(key);        end
+      def set(key, value);     @store.set encode(key), value;                    end
+      def exists?(key);        @store.exists? encode(key);                       end
+      def stale?(key);         @store.stale?  encode(key);                       end
+
+      def self.logger; @logger || default_logger; end
+      def self.default_logger; logger = ::Logger.new(STDERR); end
+
+      # Pass a filename (String), IO object, Logger instance or +nil+ to silence the logger
+      def self.logger=(device); @logger = device.kind_of?(::Logger) ? device : ::Logger.new(device); end
+
+      private
+
+      # Return store class based on passed name
+      def self.lookup_store(name)
+        store_name = "#{name.capitalize}Store"
+        return Store::const_get(store_name)
+      rescue NameError => e
+        raise Store::StoreNotFound, "The cache store '#{store_name}' was not found. Did you loaded any such class?"
+      end
+
+      def encode(key); Digest::MD5.hexdigest(key); end
+    end
+
+
+    # === Cache stores
+    # 
+    module Store
+
+      class StoreNotFound < StandardError; end #:nodoc:
+
+      # ==== Abstract Store
+      # Inherit your store from this class
+      # *IMPORTANT*: Do not forget to call +super+ in your +initialize+ method!
+      # 
+      class AbstractStore
+        def initialize(options={})
+          raise ArgumentError, "You need to set the :timeout parameter" unless options[:timeout]
+          @timeout = options[:timeout]
+          message =  "Cache: Using #{self.class.to_s.split('::').last}"
+          message << " in location: #{options[:location]}" if options[:location]
+          message << " with timeout #{options[:timeout]} sec"
+          Cache.logger.info message unless options[:logger].nil?
+          return self
+        end
+        %w{set get exists? stale?}.each do |method_name|
+          define_method(method_name) { raise NoMethodError, "Please implement method set in your store class" }
+        end
+      end
+
+      # ===== Store objects in memory
+      #
+      Struct.new("TvdbResponse", :code, :body, :headers) { def to_s; self.body; end }
+      class MemoryStore < AbstractStore
+        def initialize(options={})
+          super; @store = {}; self
+        end
+        def set(key, value)
+          Cache.logger.info("Cache: set (#{key})")
+          @store[key] = [Time.now, value]; true
+        end
+        def get(key)
+          data = @store[key][1]
+          Cache.logger.info("Cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+          data
+        end
+        def exists?(key)
+          !@store[key].nil?
+        end
+        def stale?(key)
+          return true unless exists?(key)
+          Time.now - created(key) > @timeout
+        end
+        private
+        def created(key)
+          @store[key][0]
+        end
+      end
+
+      # ===== Store objects on the filesystem
+      # 
+      class FileStore < AbstractStore
+        def initialize(options={})
+          super
+          options[:location] ||= Dir::tmpdir
+          @path = Pathname.new( options[:location] )
+          FileUtils.mkdir_p( @path )
+          self
+        end
+        def set(key, value)
+          Cache.logger.info("Cache: set (#{key})")
+          File.open( @path.join(key), 'w' ) { |file| file << Marshal.dump(value)  }
+          true
+        end
+        def get(key)
+          data = Marshal.load(File.read( @path.join(key)))
+          Cache.logger.info("Cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+          data
+        end
+        def exists?(key)
+          File.exists?( @path.join(key) )
+        end
+        def stale?(key)
+          return true unless exists?(key)
+          Time.now - created(key) > @timeout
+        end
+        private
+        def created(key)
+          File.mtime( @path.join(key) )
+        end
+      end
+    end
+
+  end
+end
+
+
+# Major parts of this code are based on architecture of ApiCache.
+# Copyright (c) 2008 Martyn Loughran
+# 
+# Other parts are inspired by the ActiveSupport::Cache in Ruby On Rails.
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/imdb_party/imdb.rb

@@ -0,0 +1,45 @@
+module ImdbParty
+  class Imdb
+    include HTTParty
+    include HTTParty::Icebox
+    cache :store => 'file', :timeout => 120, :location => Dir.tmpdir
+    
+    base_uri 'app.imdb.com'
+    default_params = {"api" => "v1", "appid" => "iphone1", "locale" => "en_US", "timestamp" => Time.now.to_i, "sig" => "heres my signature"}
+
+    
+    def find_by_title(title)
+      movie_results = []
+      results = self.class.get('/find', :query => {:q => title}).parsed_response
+      
+      if results["data"] && results["data"]["results"]
+        results["data"]["results"].each do |result_section|
+          result_section["list"].each do |r|
+            next unless r["tconst"] && r["title"]
+            h = {:title => r["title"], :year => r["year"], :imdb_id => r["tconst"]}
+            h.merge!(:poster_url => r["image"]["url"]) if r["image"] && r["image"]["url"]
+            movie_results << h
+          end
+        end
+      end
+      
+      movie_results
+    end
+
+    def find_movie_by_id(imdb_id)
+      result = self.class.get('/title/maindetails', :query => {:tconst => imdb_id}).parsed_response
+      Movie.new(result["data"]) unless result["data"].nil?
+    end
+    
+    def top_250
+      results = self.class.get('/chart/top').parsed_response
+      results["data"]["list"]["list"].map { |r| {:title => r["title"], :imdb_id => r["tconst"], :year => r["year"], :poster_url => (r["image"] ? r["image"]["url"] : nil)} }
+    end
+
+    def popular_shows
+      results = self.class.get('/chart/tv').parsed_response
+      results["data"]["list"].map { |r| {:title => r["title"], :imdb_id => r["tconst"], :year => r["year"], :poster_url => (r["image"] ? r["image"]["url"] : nil)} }
+    end
+    
+  end
+end

data/lib/imdb_party/movie.rb

@@ -0,0 +1,51 @@
+module ImdbParty
+  class Movie
+    attr_accessor :imdb_id, :title, :directors, :writers, :tagline, :company, :plot, :runtime, :rating, :poster_url, :release_date, :certification, :genres, :actors, :trailers
+
+    def initialize(options={})
+      if not options.nil? and options.keys.first.class == Symbol
+        options.keys.each { |name| instance_variable_set "@" + name.to_s, options[name] }; return
+      end
+      
+      @imdb_id = options["tconst"]
+      @title = options["title"]
+      @tagline = options["tagline"]
+      @plot = options["plot"]["outline"] if options["plot"]
+      @runtime = "#{(options["runtime"]["time"]/60).to_i} min" if options["runtime"]
+      @rating = options["rating"]
+      @poster_url = options["image"]["url"] if options["image"]
+      @release_date = options["release_date"]["normal"] if options["release_date"] && options["release_date"]["normal"]
+      @certification = options["certificate"]["certificate"] if options["certificate"] && options["certificate"]["certificate"]
+      @genres = options["genres"] || []
+      
+      # Sometimes the @release_date object is a string instead of a date object
+      if @release_date.class == String
+        [{:regex => /^\d{4}-\d{2}$/, :concat => "-01"}, {:regex => /^\d{4}$/, :concat => "-01-01"}].each do |value|
+          if @release_date.match(value[:regex])
+            @release_date = Date.parse(@release_date << value[:concat]); break
+          end
+        end
+      end
+        
+      # parse directors
+      @directors = options["directors_summary"] ? options["directors_summary"].map { |d| Person.new(d) } : []
+
+      # parse directors
+      @writers = []
+      @writers = options["writers_summary"] ? options["writers_summary"].map { |w| Person.new(w) } : []
+
+      # parse actors
+      @actors = []
+      @actors = options["cast_summary"] ? options["cast_summary"].map { |a| Person.new(a) } : []
+
+      #parse trailers
+      @trailers = {}
+      if options["trailer"] && options["trailer"]["encodings"]
+        options["trailer"]["encodings"].each_pair do |k,v|
+          @trailers[v["format"]] = v["url"]
+        end
+      end
+
+    end
+  end
+end

data/lib/imdb_party/person.rb

@@ -0,0 +1,13 @@
+module ImdbParty
+  class Person
+    attr_accessor :name, :role, :imdb_id
+    
+    def initialize(options={})
+      @name = options["name"]["name"]
+      @imdb_id = options["name"]["nconst"]
+      
+      @role = options["char"] if options["char"]
+    end
+    
+  end
+end

data/lib/movie_searcher/movie_searcher.rb

@@ -0,0 +1,63 @@
+require "#{File.dirname(__FILE__)}/../imdb_party.rb"
+require 'levenshtein'
+
+class MovieSearcher
+  def initialize(args)
+    args.keys.each { |name| instance_variable_set "@" + name.to_s, args[name] unless name == :options }
+    
+    @options = {
+      :long => 15,
+      :split => /\s+|\./,
+      :imdb => ImdbParty::Imdb.new,
+      :limit => 0.4
+    }
+    
+    @options.merge!(args[:options]) unless args[:options].nil?
+  end
+  
+  def self.find_by_release_name(search_value, options = {})
+    this = MovieSearcher.new(options.merge(:search_value => search_value.to_s))
+    return if this.to_long?
+    
+    return this.find_the_movie!
+  end
+  
+  def to_long?
+    @split = @search_value.split(@options[:split])
+    @split.length > @options[:long]
+  end
+  
+  def find_the_movie!
+    current =  @split.length
+    
+    until current <= 0 do
+      title = @split.take(current).join(' ')
+      movies = @options[:imdb].find_by_title(title)
+      break if movies.any?
+      current -= 1 
+    end
+    
+    return if movies.nil? or not movies.any?
+    
+    # Cleaning up the title, no years allowed
+    title = title.gsub(/[^a-z0-9]/i, '').gsub(/(19|20)\d{2}/, '')
+    
+    movie = movies.map do |movie| 
+      [movie, Levenshtein.normalized_distance(movie[:title].gsub(/[^a-z0-9]/i, ''), title, @options[:limit])]
+    end.reject do |value|
+      value.last.nil?
+    end.sort_by do |_,value|
+      value
+    end.first
+    
+    return if movie.nil?
+    
+    return ImdbParty::Movie.new(movie.first)
+  end
+  
+  def self.method_missing(m, *args, &block)  
+    result = ImdbParty::Imdb.new.send(m, *args)
+    return if result.nil?
+    result.class == Array ? result.map{|r| ImdbParty::Movie.new(r)} : result
+  end
+end

data/movie_searcher.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "movie_searcher"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Linus Oleander", "Jon Maddox"]
+  s.email       = ["linus@oleander.nu", "jon@mustacheinc.com"]
+  s.homepage    = "https://github.com/oleander/Undertexter"
+  s.summary     = %q{IMDB client using the IMDB API that their iPhone app uses}
+  s.description = %q{IMDB client using the IMDB API that their iPhone app uses. It can also figure out what movie you are looking for just by looking at the release name of the movie}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency('httparty')
+  s.add_dependency('levenshtein')
+  s.add_development_dependency('rspec')
+end

data/spec/movie_searcher_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe MovieSearcher do
+  it "should only contain should instances of {ImdbParty::Movie}" do
+    MovieSearcher.find_by_title("The Dark Knight").each{|movie| movie.should be_instance_of(ImdbParty::Movie)}
+  end
+  
+  it "should only contain one instance of {ImdbParty::Movie}" do
+    MovieSearcher.find_movie_by_id("tt0468569").should be_instance_of(ImdbParty::Movie)
+  end
+  
+  it "should return nil if no movie is found" do
+    MovieSearcher.find_movie_by_id("tt23223423423").should be_nil
+  end
+  
+  it "should return nil if the movie title is to long" do
+    MovieSearcher.find_by_release_name("asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd asd").should be_nil
+  end
+  
+  it "should return nil when setting the limit to low" do
+    MovieSearcher.find_by_release_name('Paranormal Activity 2 2010 UNRATED DVDRip XviD-Larceny', :options => {:limit => 0}).should be_nil
+  end
+  
+  it "should return the right movie" do
+    [{
+      :title => "Live Free Or Die Hard 2007 DVDRIP XviD-CRNTV", :iid => "tt0337978"
+    }, {
+      :title => "The Chronicles of Narnia - The Voyage of the Dawn Treader TS XViD - FLAWL3SS", :iid => "tt0980970"
+    }, {
+      :title => "Heartbreaker 2010 LIMITED DVDRip XviD-SUBMERGE", :iid => "tt1465487"
+    },{
+      :title => "Paranormal Activity 2 2010 UNRATED DVDRip XviD-Larceny", :iid => "tt1536044"
+    }].each do |movie|
+      MovieSearcher.find_by_release_name(movie[:title]).imdb_id.should eq(movie[:iid])
+    end
+  end
+  
+  it "should return nil if no value is being passed to it" do
+    MovieSearcher.find_by_release_name("").should be_nil
+  end
+  
+  it "should return nil if nil is being passed to it" do
+    MovieSearcher.find_by_release_name(nil).should be_nil
+  end
+end
+
+describe MovieSearcher, "should work as before" do
+  before(:all) do
+    @movie = MovieSearcher.find_movie_by_id("tt0382932")
+  end
+
+  it "have a title" do
+    @movie.title.should eq("Ratatouille")
+  end
+
+  it "have an imdb_id" do
+    @movie.imdb_id.should eq("tt0382932")
+  end
+
+  it "have a tagline" do
+    @movie.tagline.should eq("Dinner is served... Summer 2007")
+  end
+
+  it "have a plot" do
+    @movie.plot.should eq("Remy is a young rat in the French countryside who arrives in Paris, only to find out that his cooking idol is dead. When he makes an unusual alliance with a restaurant's new garbage boy, the culinary and personal adventures begin despite Remy's family's skepticism and the rat-hating world of humans.")
+  end
+
+  it "have a runtime" do
+    @movie.runtime.should eq("111 min")
+  end
+
+  it "have a rating" do
+    @movie.rating.should eq(8.1)
+  end
+
+  it "have a poster_url" do
+    @movie.poster_url.should match(/http:\/\/ia.media-imdb.com\/images\/.*/)
+  end
+
+  it "have a release date" do
+    @movie.release_date.should eq(DateTime.parse("2007-06-29"))
+  end
+
+  it "have a certification" do
+    @movie.certification.should  eq("G")
+  end
+
+  it "have trailers" do
+    @movie.trailers.should be_instance_of(Hash)
+    @movie.should have(4).trailers
+    @movie.trailers[@movie.trailers.keys.first].should eq("http://www.totaleclips.com/Player/Bounce.aspx?eclipid=e27826&bitrateid=461&vendorid=102&type=.mp4")
+  end
+
+  it "have genres" do
+    @movie.genres.should be_instance_of(Array)
+    @movie.should have(4).genres
+  end
+
+  it "have actors" do
+    @movie.actors.should be_instance_of(Array)
+    @movie.should have(4).actors
+  end
+
+  it "have directors" do
+    @movie.directors.should be_instance_of(Array)
+    @movie.should have(2).directors
+  end
+
+  it "have writers" do
+    @movie.writers.should be_instance_of(Array)
+    @movie.should have(2).writers
+  end
+  
+  it "always return a date object when requesting the release date" do
+    [{:imdb => "tt0066026", :date => "1970-03-01"}, {:imdb => "tt1446072", :date => "2010-11-27"}].each do |value|
+      movie = MovieSearcher.find_movie_by_id(value[:imdb])
+      movie.release_date.strftime('%Y %m %d').should eq(DateTime.parse(value[:date]).strftime('%Y %m %d'))
+      movie.release_date.should be_instance_of(Date)
+    end
+  end
+end
+
+describe MovieSearcher, "should also work as before" do
+  it "should have at least 15 results" do
+    MovieSearcher.find_by_title("ratatouille").count.should >= 15
+  end
+
+  it "search for title with spaces in the name" do
+    MovieSearcher.find_by_title("the truman show").count.should >= 1
+  end
+
+  it "search for bad title with no results" do
+    MovieSearcher.find_by_title("sdkljlkkl123j4lk23kl3").count.should eq(0)
+  end
+
+  it "find movie by id" do
+    MovieSearcher.find_movie_by_id("tt0382932").should be_instance_of(ImdbParty::Movie)
+  end
+  
+  it "be an Array of {ImdbParty::Movie}" do
+    MovieSearcher.top_250.should be_instance_of(Array)
+    MovieSearcher.top_250.first.should be_instance_of(ImdbParty::Movie)
+  end
+
+  it "find popular shows" do
+    MovieSearcher.popular_shows.should be_instance_of(Array)
+    MovieSearcher.popular_shows.first.should be_instance_of(ImdbParty::Movie)
+  end  
+end
+
+describe MovieSearcher, "should still have the same people" do
+  before(:all) do
+    @movie = MovieSearcher.find_movie_by_id("tt0382932")
+  end
+
+  it "have a name" do
+    @movie.actors.map(&:name).should include('Patton Oswalt')
+  end
+
+  it "have a role" do
+    @movie.actors.map(&:role).should include('Remy')
+  end
+
+  it "have a name" do
+    @movie.directors.map(&:name).should include('Brad Bird')
+  end
+
+  it "not have a role" do
+    @movie.directors.first.role.should be_nil
+  end
+
+  it "have a name" do
+    @movie.writers.map(&:name).should include('Brad Bird')
+  end
+
+  it "not have a role" do
+    @movie.writers.first.role.should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require "#{File.dirname(__FILE__)}/../lib/movie_searcher/movie_searcher.rb"
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: movie_searcher
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Linus Oleander
+- Jon Maddox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: levenshtein
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: IMDB client using the IMDB API that their iPhone app uses. It can also figure out what movie you are looking for just by looking at the release name of the movie
+email: 
+- linus@oleander.nu
+- jon@mustacheinc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .bundle/config
+- .document
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/imdb_party.rb
+- lib/imdb_party/httparty_icebox.rb
+- lib/imdb_party/imdb.rb
+- lib/imdb_party/movie.rb
+- lib/imdb_party/person.rb
+- lib/movie_searcher/movie_searcher.rb
+- movie_searcher.gemspec
+- spec/movie_searcher_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/oleander/Undertexter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: IMDB client using the IMDB API that their iPhone app uses
+test_files: 
+- spec/movie_searcher_spec.rb
+- spec/spec_helper.rb