ruby-tmdb3 0.3.2 → 0.3.3

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/ruby-tmdb3/tmdb.rb

@@ -49,10 +49,11 @@ class Tmdb
     method, action = method.split '/'
 
     data = {
-      api_key:  Tmdb.api_key,
-      language: language
+      :api_key =>  Tmdb.api_key
     }.merge(data)
 
+    data.merge!(:language => language) if language
+
     # Addressable can only handle hashes whose values respond to to_str, so lets be nice and convert things.
     query_values = {}
     data.each do |key,value|
@@ -71,7 +72,7 @@ class Tmdb
     # Construct URL other queries
     else
       query_values = {
-        query: CGI::escape(data[:query])
+        :query => CGI::escape(data[:query])
       }.merge(query_values)
       uri.query_values = query_values
     end
@@ -115,7 +116,7 @@ class Tmdb
       image_array = Array object.send(image_array_name)
       single_name = image_array_name.slice 0..-2 # singularize name
       single_path = object.send "#{single_name}_path" # default poster/backdrop image
-      image_array << object.send("#{image_array_name.slice 0..-2}=", DeepOpenStruct.load({file_path: single_path}))
+      image_array << object.send("#{image_array_name.slice 0..-2}=", DeepOpenStruct.load({:file_path => single_path}))
       # build a struct containing availables sizes with their urls
       image_array.each do |image|
         urls = CONFIGURATION.images.send("#{image_array_name}_sizes").inject({}) do |hash, size|

data/lib/ruby-tmdb3/tmdb_cast.rb

@@ -10,10 +10,10 @@ class TmdbCast
     
     results = []
     unless(options[:id].nil? || options[:id].to_s.empty?)
-      results << Tmdb.api_call("person", {id: options[:id].to_s}, options[:language])
+      results << Tmdb.api_call("person", {:id => options[:id].to_s}, options[:language])
     end
     unless(options[:name].nil? || options[:name].to_s.empty?)
-      api_return = Tmdb.api_call('search/person', {query: options[:name].to_s}, options[:language])
+      api_return = Tmdb.api_call('search/person', {:query => options[:name].to_s}, options[:language])
       results << api_return["results"] if api_return
     end
     
@@ -40,7 +40,7 @@ class TmdbCast
     # (as determined by checking for the 'birthday' property)
     if(expand_results && !raw_data.has_key?("birthday"))
       begin
-        expanded_data = Tmdb.api_call("person", {id: raw_data["id"].to_s}, language)
+        expanded_data = Tmdb.api_call("person", {:id => raw_data["id"].to_s}, language)
       rescue RuntimeError => e
         raise ArgumentError, "Unable to fetch expanded info for Cast ID: '#{raw_data["id"]}'" if expanded_data.nil?
       end

data/lib/ruby-tmdb3/tmdb_movie.rb

@@ -10,14 +10,14 @@ class TmdbMovie
     
     results = []
     unless(options[:id].nil? || options[:id].to_s.empty?)
-      results << Tmdb.api_call("movie", {id: options[:id].to_s}, options[:language])
+      results << Tmdb.api_call("movie", {:id => options[:id].to_s}, options[:language])
     end
     unless(options[:title].nil? || options[:title].to_s.empty?)
-      api_return = Tmdb.api_call("search/movie", {query: options[:title].to_s}, options[:language])
+      api_return = Tmdb.api_call("search/movie", {:query => options[:title].to_s}, options[:language])
       results << api_return["results"] if api_return
     end
     unless(options[:imdb].nil? || options[:imdb].to_s.empty?)
-      results << Tmdb.api_call("movie", {id: options[:imdb].to_s}, options[:language])
+      results << Tmdb.api_call("movie", {:id => options[:imdb].to_s}, options[:language])
       options[:expand_results] = true
     end
     
@@ -45,10 +45,10 @@ class TmdbMovie
     if(expand_results && (!raw_data.has_key?("posters") || !raw_data['releases'] || !raw_data['cast']))
       begin
         movie_id              = raw_data['id']
-        raw_data              = Tmdb.api_call 'movie', { id: movie_id }, language
-        @images_data          = Tmdb.api_call("movie/images", {id: movie_id}, language)
-        @releases_data        = Tmdb.api_call('movie/releases', {id: movie_id}, language)
-        @cast_data            = Tmdb.api_call('movie/casts', {id: movie_id}, language)
+        raw_data              = Tmdb.api_call 'movie', { :id => movie_id }, language
+        @images_data          = Tmdb.api_call("movie/images", {:id => movie_id}, language)
+        @releases_data        = Tmdb.api_call('movie/releases', {:id => movie_id}, language)
+        @cast_data            = Tmdb.api_call('movie/casts', {:id => movie_id}, language)
         raw_data['posters']   = @images_data['posters']
         raw_data['backdrops'] = @images_data['backdrops']
         raw_data['releases']  = @releases_data['countries']

data/ruby-tmdb3.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "ruby-tmdb3"
-  s.version = "0.3.2"
+  s.version = "0.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Irio Irineu Musskopf Junior", "Aaron Gough"]
-  s.date = "2012-08-20"
+  s.date = "2012-09-15"
   s.description = "An ActiveRecord-style API wrapper for TheMovieDB.org"
   s.email = "iirineu@gmail.com"
   s.extra_rdoc_files = [

data/test/setup/setup_api_key.rb

@@ -1,5 +1,5 @@
 begin
-  file_path = File.absolute_path('tmdb_api_key.txt', File.dirname(__FILE__))
+  file_path = File.expand_path('tmdb_api_key.txt', File.dirname(__FILE__))
 
   File.open(file_path) do |file|
     Tmdb.api_key = file.read.chomp

data/test/unit/tmdb_cast_test.rb

@@ -87,20 +87,20 @@ class TmdbCastTest < Test::Unit::TestCase
 
   test "should pass default language to Tmdb.api_call if language is not supplied" do
     Tmdb.expects(:api_call).
-      with("person", {id: "1"}, Tmdb.default_language).returns(nil)
+      with("person", {:id => "1"}, Tmdb.default_language).returns(nil)
     Tmdb.expects(:api_call).
-      with("search/person", {query: "1"}, Tmdb.default_language).returns(nil)
+      with("search/person", {:query => "1"}, Tmdb.default_language).returns(nil)
     TmdbCast.find(:id => 1, :name => 1)
   end
 
   test "should pass through language to Tmdb.api_call when language is supplied" do
-    Tmdb.expects(:api_call).with("person", {id: "1"}, "foo").returns(nil)
-    Tmdb.expects(:api_call).with("search/person", {query: "1"}, "foo").returns(nil)
+    Tmdb.expects(:api_call).with("person", {:id => "1"}, "foo").returns(nil)
+    Tmdb.expects(:api_call).with("search/person", {:query => "1"}, "foo").returns(nil)
     TmdbCast.find(:id => 1, :name => 1, :language => "foo")
   end
 
   test "TmdbCast.new should raise error if supplied with raw data for cast member that doesn't exist" do
-    Tmdb.expects(:api_call).with("person", {id: "999999999999"}, nil).returns(nil)
+    Tmdb.expects(:api_call).with("person", {:id => "999999999999"}, nil).returns(nil)
     assert_raise ArgumentError do
       TmdbCast.new({"id" => 999999999999}, true)
     end
@@ -109,7 +109,7 @@ class TmdbCastTest < Test::Unit::TestCase
   private
   
     def assert_cast_methodized(actor, cast_id)
-      @cast_data = Tmdb.api_call("person", {id: cast_id.to_s}, Tmdb.default_language)
+      @cast_data = Tmdb.api_call("person", {:id => cast_id.to_s}, Tmdb.default_language)
       assert_equal @cast_data["adult"], actor.adult
       assert_equal @cast_data["also_known_as"], actor.also_known_as
       assert_equal @cast_data["biography"], actor.biography

data/test/unit/tmdb_movie_test.rb

@@ -93,22 +93,22 @@ class TmdbMovieTest < Test::Unit::TestCase
   end
   
   test "find should pass default language to Tmdb.api_call if language is not supplied" do
-    Tmdb.expects(:api_call).with("movie", {id: "1"}, Tmdb.default_language).twice
-    Tmdb.expects(:api_call).with("search/movie", {query: "1"}, Tmdb.default_language)
+    Tmdb.expects(:api_call).with("movie", {:id => "1"}, Tmdb.default_language).twice
+    Tmdb.expects(:api_call).with("search/movie", {:query => "1"}, Tmdb.default_language)
     TmdbMovie.find(:id => 1, :imdb => 1, :title => 1)
   end
   
   test "find should pass through language to Tmdb.api_call when language is supplied" do
-    Tmdb.expects(:api_call).with("movie", {id: "1"}, "foo").twice
-    Tmdb.expects(:api_call).with("search/movie", {query: "1"}, "foo")
+    Tmdb.expects(:api_call).with("movie", {:id => "1"}, "foo").twice
+    Tmdb.expects(:api_call).with("search/movie", {:query => "1"}, "foo")
     TmdbMovie.find(:id => 1, :imdb => 1, :title => 1, :language => "foo")
   end
   
   test "TmdbMovie.new should raise error if supplied with raw data for movie that doesn't exist" do
-    Tmdb.expects(:api_call).with("movie", {id: 999999999999}, nil).returns(nil)
-    Tmdb.expects(:api_call).with("movie/images", {id: 999999999999}, nil).returns(nil)
-    Tmdb.expects(:api_call).with("movie/releases", {id: 999999999999}, nil).returns(nil)
-    Tmdb.expects(:api_call).with("movie/casts", {id: 999999999999}, nil).returns(nil)
+    Tmdb.expects(:api_call).with("movie", {:id => 999999999999}, nil).returns(nil)
+    Tmdb.expects(:api_call).with("movie/images", {:id => 999999999999}, nil).returns(nil)
+    Tmdb.expects(:api_call).with("movie/releases", {:id => 999999999999}, nil).returns(nil)
+    Tmdb.expects(:api_call).with("movie/casts", {:id => 999999999999}, nil).returns(nil)
     assert_raise ArgumentError do
       TmdbMovie.new({"id" => 999999999999}, true)
     end
@@ -117,7 +117,7 @@ class TmdbMovieTest < Test::Unit::TestCase
   private
     
     def assert_movie_methodized(movie, movie_id)
-      @movie_data = Tmdb.api_call("movie", {id: movie_id.to_s}, Tmdb.default_language)
+      @movie_data = Tmdb.api_call("movie", {:id => movie_id.to_s}, Tmdb.default_language)
       assert_equal @movie_data["adult"], movie.adult
       assert_equal @movie_data["budget"], movie.budget
       assert_equal @movie_data["homepage"], movie.homepage

data/test/unit/tmdb_test.rb

@@ -51,7 +51,7 @@ class TmdbTest < Test::Unit::TestCase
     url = Tmdb.base_api_url + '/' + method + "?api_key=" + Tmdb.api_key + "&language=" + language + '&query=' + CGI::escape(data.to_s)
     mock_response = stub(:code => "200", :body => '{"page":1,"results":[],"total_pages":0,"total_results":0}')
     Tmdb.expects(:get_url).with(url).returns(mock_response)
-    Tmdb.api_call(method, {query: data}, language)
+    Tmdb.api_call(method, {:query => data}, language)
   end
   
   test "api_call should raise exception if api_key is not set" do
@@ -64,7 +64,7 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "should perform search/movie API call and return a Hash with an array of results" do
-    movies = Tmdb.api_call("search/movie", {query: "Transformers"})
+    movies = Tmdb.api_call("search/movie", {:query => "Transformers"})
     assert_kind_of Hash, movies
     assert_kind_of Array, movies["results"]
     movies["results"].each do |movie|
@@ -76,7 +76,7 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "should perform movie API call and return a single result" do
-    result = Tmdb.api_call("movie", {id: "187"})
+    result = Tmdb.api_call("movie", {:id => "187"})
     assert_kind_of Hash, result
     %w(original_title id).each do |item|
       assert_not_nil result[item]
@@ -84,7 +84,7 @@ class TmdbTest < Test::Unit::TestCase
   end
 
   test "should perform movie API call with an action and return a single result" do
-    result = Tmdb.api_call("movie/images", {id: "187"})
+    result = Tmdb.api_call("movie/images", {:id => "187"})
     assert_kind_of Hash, result
     %w(posters id).each do |item|
       assert_not_nil result[item]
@@ -92,7 +92,7 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "should perform Movie.imdbLookup API call and return a single result" do
-    result = Tmdb.api_call("movie", {id: "tt0401792"})
+    result = Tmdb.api_call("movie", {:id => "tt0401792"})
     assert_kind_of Hash, result
     %w(original_title id).each do |item|
       assert result[item]
@@ -100,7 +100,7 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "should perform person API call and return a single result" do
-    result = Tmdb.api_call("person", {id: 287})
+    result = Tmdb.api_call("person", {:id => 287})
     assert_kind_of Hash, result
     %w(homepage id name).each do |item|
       assert_not_nil result[item]
@@ -108,7 +108,7 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "should perform search/person API call and return a Hash with an array of results" do
-    people = Tmdb.api_call("search/person", {query: "vince"})
+    people = Tmdb.api_call("search/person", {:query => "vince"})
     assert_kind_of Array, people["results"]
     people["results"].each do |person|
       assert_kind_of Hash, person
@@ -125,15 +125,15 @@ class TmdbTest < Test::Unit::TestCase
   end
   
   test "API call that finds no results should return nil" do
-    movies = Tmdb.api_call('search/movie', {query: "item_not_found"})
+    movies = Tmdb.api_call('search/movie', {:query => "item_not_found"})
     assert_nil movies
   end
   
   test "API call cache should not be changed when data altered in the receiving method" do
-    person = Tmdb.api_call("person", {id: 287})
+    person = Tmdb.api_call("person", {:id => 287})
     assert_not_nil person[person.keys[0]]
     person[person.keys[0]] = nil
-    person = Tmdb.api_call("person", {id: 287})
+    person = Tmdb.api_call("person", {:id => 287})
     assert_not_nil person[person.keys[0]]
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-tmdb3
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-20 00:00:00.000000000 Z
+date: 2012-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deepopenstruct