activeresource 2.1.2 → 2.2.2

data/lib/active_resource/connection.rb

@@ -28,24 +28,24 @@ module ActiveResource
 
   # 3xx Redirection
   class Redirection < ConnectionError # :nodoc:
-    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end    
-  end 
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
+  end
 
   # 4xx Client Error
   class ClientError < ConnectionError; end # :nodoc:
-  
+
   # 400 Bad Request
   class BadRequest < ClientError; end # :nodoc
-  
+
   # 401 Unauthorized
   class UnauthorizedAccess < ClientError; end # :nodoc
-  
+
   # 403 Forbidden
   class ForbiddenAccess < ClientError; end # :nodoc
-  
+
   # 404 Not Found
   class ResourceNotFound < ClientError; end # :nodoc:
-  
+
   # 409 Conflict
   class ResourceConflict < ClientError; end # :nodoc:
 
@@ -63,6 +63,13 @@ module ActiveResource
   # This class is used by ActiveResource::Base to interface with REST
   # services.
   class Connection
+
+    HTTP_FORMAT_HEADER_NAMES = {  :get => 'Accept',
+      :put => 'Content-Type',
+      :post => 'Content-Type',
+      :delete => 'Accept'
+    }
+
     attr_reader :site, :user, :password, :timeout
     attr_accessor :format
 
@@ -106,25 +113,25 @@ module ActiveResource
     # Execute a GET request.
     # Used to get (find) resources.
     def get(path, headers = {})
-      format.decode(request(:get, path, build_request_headers(headers)).body)
+      format.decode(request(:get, path, build_request_headers(headers, :get)).body)
     end
 
     # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
     # Used to delete resources.
     def delete(path, headers = {})
-      request(:delete, path, build_request_headers(headers))
+      request(:delete, path, build_request_headers(headers, :delete))
     end
 
     # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
     # Used to update resources.
     def put(path, body = '', headers = {})
-      request(:put, path, body.to_s, build_request_headers(headers))
+      request(:put, path, body.to_s, build_request_headers(headers, :put))
     end
 
     # Execute a POST request.
     # Used to create new resources.
     def post(path, body = '', headers = {})
-      request(:post, path, body.to_s, build_request_headers(headers))
+      request(:post, path, body.to_s, build_request_headers(headers, :post))
     end
 
     # Execute a HEAD request.
@@ -140,7 +147,7 @@ module ActiveResource
         logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
         result = nil
         time = Benchmark.realtime { result = http.send(method, path, *arguments) }
-        logger.info "--> #{result.code} #{result.message} (#{result.body ? result.body.length : 0}b %.2fs)" % time if logger
+        logger.info "--> %d %s (%d %.2fs)" % [result.code, result.message, result.body ? result.body.length : 0, time] if logger
         handle_response(result)
       rescue Timeout::Error => e
         raise TimeoutError.new(e.message)
@@ -187,12 +194,12 @@ module ActiveResource
       end
 
       def default_header
-        @default_header ||= { 'Content-Type' => format.mime_type }
+        @default_header ||= {}
       end
 
       # Builds headers for request to remote service.
-      def build_request_headers(headers)
-        authorization_header.update(default_header).update(headers)
+      def build_request_headers(headers, http_method=nil)
+        authorization_header.update(default_header).update(http_format_header(http_method)).update(headers)
       end
 
       # Sets authorization header
@@ -200,8 +207,12 @@ module ActiveResource
         (@user || @password ? { 'Authorization' => 'Basic ' + ["#{@user}:#{ @password}"].pack('m').delete("\r\n") } : {})
       end
 
+      def http_format_header(http_method)
+        {HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type}
+      end
+
       def logger #:nodoc:
-        ActiveResource::Base.logger
+        Base.logger
       end
   end
 end

data/lib/active_resource/custom_methods.rb

@@ -30,7 +30,7 @@ module ActiveResource
   #   Person.get(:active)  # GET /people/active.xml
   #   # => [{:id => 1, :name => 'Ryan'}, {:id => 2, :name => 'Joe'}]
   #
-  module CustomMethods 
+  module CustomMethods
     def self.included(base)
       base.class_eval do
         extend ActiveResource::CustomMethods::ClassMethods
@@ -48,8 +48,8 @@ module ActiveResource
           #   # => [{:id => 1, :name => 'Ryan'}]
           #
           # Note: the objects returned from this method are not automatically converted
-          # into Active Resource instances - they are ordinary Hashes. If you are expecting
-          # Active Resource instances, use the <tt>find</tt> class method with the
+          # into ActiveResource::Base instances - they are ordinary Hashes. If you are expecting
+          # ActiveResource::Base instances, use the <tt>find</tt> class method with the
           # <tt>:from</tt> option. For example:
           #
           #   Person.find(:all, :from => :active)
@@ -83,24 +83,25 @@ module ActiveResource
         "#{prefix(prefix_options)}#{collection_name}/#{method_name}.#{format.extension}#{query_string(query_options)}"
       end
     end
-    
+
     module InstanceMethods
       def get(method_name, options = {})
         connection.get(custom_method_element_url(method_name, options), self.class.headers)
       end
-      
-      def post(method_name, options = {}, body = '')
+
+      def post(method_name, options = {}, body = nil)
+        request_body = body.blank? ? encode : body
         if new?
-          connection.post(custom_method_new_element_url(method_name, options), (body.nil? ? to_xml : body), self.class.headers)
+          connection.post(custom_method_new_element_url(method_name, options), request_body, self.class.headers)
         else
-          connection.post(custom_method_element_url(method_name, options), body, self.class.headers)
+          connection.post(custom_method_element_url(method_name, options), request_body, self.class.headers)
         end
       end
-      
+
       def put(method_name, options = {}, body = '')
         connection.put(custom_method_element_url(method_name, options), body, self.class.headers)
       end
-      
+
       def delete(method_name, options = {})
         connection.delete(custom_method_element_url(method_name, options), self.class.headers)
       end
@@ -108,11 +109,11 @@ module ActiveResource
 
       private
         def custom_method_element_url(method_name, options = {})
-          "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}.#{self.class.format.extension}#{self.class.send!(:query_string, options)}"
+          "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}.#{self.class.format.extension}#{self.class.__send__(:query_string, options)}"
         end
-      
+
         def custom_method_new_element_url(method_name, options = {})
-          "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/new/#{method_name}.#{self.class.format.extension}#{self.class.send!(:query_string, options)}"
+          "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/new/#{method_name}.#{self.class.format.extension}#{self.class.__send__(:query_string, options)}"
         end
     end
   end

data/lib/active_resource/formats/json_format.rb

@@ -2,22 +2,22 @@ module ActiveResource
   module Formats
     module JsonFormat
       extend self
-      
+
       def extension
         "json"
       end
-      
+
       def mime_type
         "application/json"
       end
-      
-      def encode(hash)
-        hash.to_json
+
+      def encode(hash, options={})
+        hash.to_json(options)
       end
-      
+
       def decode(json)
         ActiveSupport::JSON.decode(json)
       end
     end
   end
-end
+end

data/lib/active_resource/formats/xml_format.rb

@@ -2,23 +2,23 @@ module ActiveResource
   module Formats
     module XmlFormat
       extend self
-      
+
       def extension
         "xml"
       end
-      
+
       def mime_type
         "application/xml"
       end
-      
-      def encode(hash)
-        hash.to_xml
+
+      def encode(hash, options={})
+        hash.to_xml(options)
       end
-      
+
       def decode(xml)
         from_xml_data(Hash.from_xml(xml))
       end
-      
+
       private
         # Manipulate from_xml Hash, because xml_simple is not exactly what we
         # want for Active Resource.
@@ -28,7 +28,7 @@ module ActiveResource
           else
             data
           end
-        end      
+        end
     end
   end
-end
+end

data/lib/active_resource/http_mock.rb

@@ -65,7 +65,7 @@ module ActiveResource
     class << self
 
       # Returns an array of all request objects that have been sent to the mock.  You can use this to check
-      # wether or not your model actually sent an HTTP request.
+      # if your model actually sent an HTTP request.
       #
       # ==== Example
       #   def setup
@@ -146,7 +146,7 @@ module ActiveResource
     attr_accessor :path, :method, :body, :headers
 
     def initialize(method, path, body = nil, headers = {})
-      @method, @path, @body, @headers = method, path, body, headers.reverse_merge('Content-Type' => 'application/xml')
+      @method, @path, @body, @headers = method, path, body, headers.merge(ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[method] => 'application/xml')
     end
 
     def ==(other_request)

data/lib/active_resource/validations.rb

@@ -216,39 +216,25 @@ module ActiveResource
     end
   end
   
-  # Module to allow validation of Active Resource objects, which creates an Errors instance for every resource.
-  # Methods are implemented by overriding Base#validate or its variants   Each of these methods can inspect 
-  # the state of the object, which usually means  ensuring that a number of attributes have a certain value 
-  # (such as not empty, within a given range, matching a certain regular expression and so on).
+  # Module to support validation and errors with Active Resource objects. The module overrides
+  # Base#save to rescue ActiveResource::ResourceInvalid exceptions and parse the errors returned 
+  # in the web service response. The module also adds an +errors+ collection that mimics the interface 
+  # of the errors provided by ActiveRecord::Errors.
   #
   # ==== Example
   #
-  #   class Person < ActiveResource::Base
-  #      self.site = "http://www.localhost.com:3000/"
-  #      protected
-  #        def validate
-  #          errors.add_on_empty %w( first_name last_name )
-  #          errors.add("phone_number", "has invalid format") unless phone_number =~ /[0-9]*/
-  #        end
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a 
+  # <tt>validates_presence_of :first_name, :last_name</tt> declaration in the model:
   #
-  #        def validate_on_create # is only run the first time a new object is saved
-  #          unless valid_member?(self)
-  #            errors.add("membership_discount", "has expired")
-  #          end
-  #        end
-  #
-  #        def validate_on_update
-  #          errors.add_to_base("No changes have occurred") if unchanged_attributes?
-  #        end
-  #   end
-  #   
-  #   person = Person.new("first_name" => "Jim", "phone_number" => "I will not tell you.")
-  #   person.save                         # => false (and doesn't do the save)
-  #   person.errors.empty?                # => false
-  #   person.errors.count                 # => 2
-  #   person.errors.on "last_name"        # => "can't be empty"
-  #   person.attributes = { "last_name" => "Halpert", "phone_number" => "555-5555" }
-  #   person.save                         # => true (and person is now saved to the remote service)
+  #   person = Person.new(:first_name => "Jim", :last_name => "")
+  #   person.save                   # => false (server returns an HTTP 422 status code and errors)
+  #   person.valid?                 # => false
+  #   person.errors.empty?          # => false
+  #   person.errors.count           # => 1
+  #   person.errors.full_messages   # => ["Last name can't be empty"]
+  #   person.errors.on(:last_name)  # => "can't be empty"
+  #   person.last_name = "Halpert"  
+  #   person.save                   # => true (and person is now saved to the remote service)
   #
   module Validations
     def self.included(base) # :nodoc:

data/lib/active_resource/version.rb

@@ -1,7 +1,7 @@
 module ActiveResource
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 1
+    MINOR = 2
     TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/test/authorization_test.rb

@@ -19,7 +19,7 @@ class AuthorizationTest < Test::Unit::TestCase
   end
 
   def test_authorization_header
-    authorization_header = @authenticated_conn.send!(:authorization_header)
+    authorization_header = @authenticated_conn.__send__(:authorization_header)
     assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
     authorization = authorization_header["Authorization"].to_s.split
     
@@ -29,7 +29,7 @@ class AuthorizationTest < Test::Unit::TestCase
   
   def test_authorization_header_with_username_but_no_password
     @conn = ActiveResource::Connection.new("http://david:@localhost")
-    authorization_header = @conn.send!(:authorization_header)
+    authorization_header = @conn.__send__(:authorization_header)
     authorization = authorization_header["Authorization"].to_s.split
     
     assert_equal "Basic", authorization[0]
@@ -38,7 +38,7 @@ class AuthorizationTest < Test::Unit::TestCase
   
   def test_authorization_header_with_password_but_no_username
     @conn = ActiveResource::Connection.new("http://:test123@localhost")
-    authorization_header = @conn.send!(:authorization_header)
+    authorization_header = @conn.__send__(:authorization_header)
     authorization = authorization_header["Authorization"].to_s.split
     
     assert_equal "Basic", authorization[0]
@@ -47,7 +47,7 @@ class AuthorizationTest < Test::Unit::TestCase
   
   def test_authorization_header_with_decoded_credentials_from_url
     @conn = ActiveResource::Connection.new("http://my%40email.com:%31%32%33@localhost")
-    authorization_header = @conn.send!(:authorization_header)
+    authorization_header = @conn.__send__(:authorization_header)
     authorization = authorization_header["Authorization"].to_s.split
 
     assert_equal "Basic", authorization[0]
@@ -58,7 +58,7 @@ class AuthorizationTest < Test::Unit::TestCase
     @authenticated_conn = ActiveResource::Connection.new("http://@localhost")
     @authenticated_conn.user = 'david'
     @authenticated_conn.password = 'test123'
-    authorization_header = @authenticated_conn.send!(:authorization_header)
+    authorization_header = @authenticated_conn.__send__(:authorization_header)
     assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
     authorization = authorization_header["Authorization"].to_s.split
 
@@ -69,7 +69,7 @@ class AuthorizationTest < Test::Unit::TestCase
   def test_authorization_header_explicitly_setting_username_but_no_password
     @conn = ActiveResource::Connection.new("http://@localhost")
     @conn.user = "david"
-    authorization_header = @conn.send!(:authorization_header)
+    authorization_header = @conn.__send__(:authorization_header)
     authorization = authorization_header["Authorization"].to_s.split
 
     assert_equal "Basic", authorization[0]
@@ -79,7 +79,7 @@ class AuthorizationTest < Test::Unit::TestCase
   def test_authorization_header_explicitly_setting_password_but_no_username
     @conn = ActiveResource::Connection.new("http://@localhost")
     @conn.password = "test123"
-    authorization_header = @conn.send!(:authorization_header)
+    authorization_header = @conn.__send__(:authorization_header)
     authorization = authorization_header["Authorization"].to_s.split
 
     assert_equal "Basic", authorization[0]
@@ -116,7 +116,7 @@ class AuthorizationTest < Test::Unit::TestCase
   protected
     def assert_response_raises(klass, code)
       assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
-        @conn.send!(:handle_response, Response.new(code))
+        @conn.__send__(:handle_response, Response.new(code))
       end
     end
 end

data/test/base/custom_methods_test.rb

@@ -10,8 +10,7 @@ class CustomMethodsTest < Test::Unit::TestCase
     @ryan  = { :name => 'Ryan' }.to_xml(:root => 'person')
     @addy  = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
     @addy_deep  = { :id => 1, :street => '12345 Street', :zip => "27519" }.to_xml(:root => 'address')
-    @default_request_headers = { 'Content-Type' => 'application/xml' }
-    
+
     ActiveResource::HttpMock.respond_to do |mock|
       mock.get    "/people/1.xml",             {}, @matz
       mock.get    "/people/1/shallow.xml", {}, @matz
@@ -82,6 +81,8 @@ class CustomMethodsTest < Test::Unit::TestCase
     # Test POST against a new element URL
     ryan = Person.new(:name => 'Ryan')
     assert_equal ActiveResource::Response.new(@ryan, 201, {'Location' => '/people/5.xml'}), ryan.post(:register)
+    expected_request = ActiveResource::Request.new(:post, '/people/new/register.xml', @ryan)
+    assert_equal expected_request.body, ActiveResource::HttpMock.requests.first.body
 
     # Test POST against a nested collection URL
     addy = StreetAddress.new(:street => '123 Test Dr.', :person_id => 1)

data/test/base/load_test.rb

@@ -84,7 +84,7 @@ class BaseLoadTest < Test::Unit::TestCase
   end
 
   def test_load_collection_with_unknown_resource
-    Person.send!(:remove_const, :Address) if Person.const_defined?(:Address)
+    Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
     assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
     addresses = silence_warnings { @person.load(:addresses => @addresses).addresses }
     assert Person.const_defined?(:Address), "Address should have been autocreated"
@@ -100,7 +100,7 @@ class BaseLoadTest < Test::Unit::TestCase
   end
 
   def test_load_collection_with_single_unknown_resource
-    Person.send!(:remove_const, :Address) if Person.const_defined?(:Address)
+    Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
     assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
     addresses = silence_warnings { @person.load(:addresses => [ @first_address ]).addresses }
     assert Person.const_defined?(:Address), "Address should have been autocreated"

data/test/base_test.rb

@@ -8,7 +8,7 @@ class BaseTest < Test::Unit::TestCase
   def setup
     @matz  = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
     @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
-    @greg  = { :id => 3, :name => 'Greg' }.to_xml(:root => 'person')    
+    @greg  = { :id => 3, :name => 'Greg' }.to_xml(:root => 'person')
     @addy  = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
     @default_request_headers = { 'Content-Type' => 'application/xml' }
     @rick = { :name => "Rick", :age => 25 }.to_xml(:root => "person")
@@ -46,11 +46,25 @@ class BaseTest < Test::Unit::TestCase
                                            :children => [{:name => 'Natacha'}]},
                                           {:name => 'Milena',
                                            :children => []}]}]}.to_xml(:root => 'customer')
+    # - resource with yaml array of strings; for ActiveRecords using serialize :bar, Array
+    @marty = <<-eof
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <person>
+        <id type=\"integer\">5</id>
+        <name>Marty</name>
+        <colors type=\"yaml\">---
+      - \"red\"
+      - \"green\"
+      - \"blue\"
+      </colors>
+      </person>
+    eof
 
     ActiveResource::HttpMock.respond_to do |mock|
       mock.get    "/people/1.xml",                {}, @matz
       mock.get    "/people/2.xml",                {}, @david
-      mock.get    "/people/Greg.xml",             {}, @greg      
+      mock.get    "/people/5.xml",                {}, @marty
+      mock.get    "/people/Greg.xml",             {}, @greg
       mock.get    "/people/4.xml",                {'key' => 'value'}, nil, 404
       mock.put    "/people/1.xml",                {}, nil, 204
       mock.delete "/people/1.xml",                {}, nil, 200
@@ -62,7 +76,7 @@ class BaseTest < Test::Unit::TestCase
       mock.get    "/people/1/addresses/1.xml",    {}, @addy
       mock.get    "/people/1/addresses/2.xml",    {}, nil, 404
       mock.get    "/people/2/addresses/1.xml",    {}, nil, 404
-      mock.get    "/people/Greg/addresses/1.xml", {}, @addy      
+      mock.get    "/people/Greg/addresses/1.xml", {}, @addy
       mock.put    "/people/1/addresses/1.xml",    {}, nil, 204
       mock.delete "/people/1/addresses/1.xml",    {}, nil, 200
       mock.post   "/people/1/addresses.xml",      {}, nil, 201, 'Location' => '/people/1/addresses/5'
@@ -101,13 +115,13 @@ class BaseTest < Test::Unit::TestCase
     assert_equal 'http://foo:bar@beast.caboo.se', Forum.site.to_s
     assert_equal 'http://foo:bar@beast.caboo.se/forums/:forum_id', Topic.site.to_s
   end
-  
+
   def test_site_variable_can_be_reset
-    actor = Class.new(ActiveResource::Base)    
+    actor = Class.new(ActiveResource::Base)
     assert_nil actor.site
     actor.site = 'http://localhost:31337'
     actor.site = nil
-    assert_nil actor.site    
+    assert_nil actor.site
   end
 
   def test_should_accept_setting_user
@@ -194,18 +208,18 @@ class BaseTest < Test::Unit::TestCase
     actor.site = 'http://nomad'
     assert_equal actor.site, jester.site
     assert jester.site.frozen?
-    
-    # Subclasses are always equal to superclass site when not overridden    
+
+    # Subclasses are always equal to superclass site when not overridden
     fruit = Class.new(ActiveResource::Base)
     apple = Class.new(fruit)
-    
+
     fruit.site = 'http://market'
     assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
-    
+
     fruit.site = 'http://supermarket'
     assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
   end
-  
+
   def test_user_reader_uses_superclass_user_until_written
     # Superclass is Object so returns nil.
     assert_nil ActiveResource::Base.user
@@ -317,14 +331,14 @@ class BaseTest < Test::Unit::TestCase
   end
 
   def test_updating_baseclass_site_object_wipes_descendent_cached_connection_objects
-    # Subclasses are always equal to superclass site when not overridden    
+    # Subclasses are always equal to superclass site when not overridden
     fruit = Class.new(ActiveResource::Base)
     apple = Class.new(fruit)
-    
+
     fruit.site = 'http://market'
     assert_equal fruit.connection.site, apple.connection.site
     first_connection = apple.connection.object_id
-    
+
     fruit.site = 'http://supermarket'
     assert_equal fruit.connection.site, apple.connection.site
     second_connection = apple.connection.object_id
@@ -393,34 +407,34 @@ class BaseTest < Test::Unit::TestCase
     assert_equal '/people.xml?gender=', Person.collection_path(:gender => nil)
 
     assert_equal '/people.xml?gender=male', Person.collection_path('gender' => 'male')
-    
+
     # Use includes? because ordering of param hash is not guaranteed
     assert Person.collection_path(:gender => 'male', :student => true).include?('/people.xml?')
     assert Person.collection_path(:gender => 'male', :student => true).include?('gender=male')
     assert Person.collection_path(:gender => 'male', :student => true).include?('student=true')
 
     assert_equal '/people.xml?name%5B%5D=bob&name%5B%5D=your+uncle%2Bme&name%5B%5D=&name%5B%5D=false', Person.collection_path(:name => ['bob', 'your uncle+me', nil, false])
-    
+
     assert_equal '/people.xml?struct%5Ba%5D%5B%5D=2&struct%5Ba%5D%5B%5D=1&struct%5Bb%5D=fred', Person.collection_path(:struct => {:a => [2,1], 'b' => 'fred'})
   end
 
   def test_custom_element_path
     assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, :person_id => 1)
     assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 1)
-    assert_equal '/people/Greg/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 'Greg')    
+    assert_equal '/people/Greg/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 'Greg')
   end
-  
+
   def test_custom_element_path_with_redefined_to_param
     Person.module_eval do
       alias_method :original_to_param_element_path, :to_param
-       def to_param  
+       def to_param
          name
        end
     end
 
     # Class method.
     assert_equal '/people/Greg.xml', Person.element_path('Greg')
-    
+
     # Protected Instance method.
     assert_equal '/people/Greg.xml', Person.find('Greg').send(:element_path)
 
@@ -468,16 +482,16 @@ class BaseTest < Test::Unit::TestCase
 
   def test_prefix
     assert_equal "/", Person.prefix
-    assert_equal Set.new, Person.send!(:prefix_parameters)
+    assert_equal Set.new, Person.__send__(:prefix_parameters)
   end
-  
+
   def test_set_prefix
     SetterTrap.rollback_sets(Person) do |person_class|
       person_class.prefix = "the_prefix"
       assert_equal "the_prefix", person_class.prefix
     end
   end
-  
+
   def test_set_prefix_with_inline_keys
     SetterTrap.rollback_sets(Person) do |person_class|
       person_class.prefix = "the_prefix:the_param"
@@ -504,7 +518,7 @@ class BaseTest < Test::Unit::TestCase
   def test_custom_prefix
     assert_equal '/people//', StreetAddress.prefix
     assert_equal '/people/1/', StreetAddress.prefix(:person_id => 1)
-    assert_equal [:person_id].to_set, StreetAddress.send!(:prefix_parameters)
+    assert_equal [:person_id].to_set, StreetAddress.__send__(:prefix_parameters)
   end
 
   def test_find_by_id
@@ -513,7 +527,7 @@ class BaseTest < Test::Unit::TestCase
     assert_equal "Matz", matz.name
     assert matz.name?
   end
-  
+
   def test_respond_to
     matz = Person.find(1)
     assert matz.respond_to?(:name)
@@ -542,6 +556,12 @@ class BaseTest < Test::Unit::TestCase
     assert_equal "Matz", matz.name
   end
 
+  def test_find_last
+    david = Person.find(:last)
+    assert_kind_of Person, david
+    assert_equal 'David', david.name
+  end
+
   def test_custom_header
     Person.headers['key'] = 'value'
     assert_raises(ActiveResource::ResourceNotFound) { Person.find(4) }
@@ -556,7 +576,7 @@ class BaseTest < Test::Unit::TestCase
 
   def test_find_all_by_from
     ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.xml", {}, @people_david }
-  
+
     people = Person.find(:all, :from => "/companies/1/people.xml")
     assert_equal 1, people.size
     assert_equal "David", people.first.name
@@ -564,7 +584,7 @@ class BaseTest < Test::Unit::TestCase
 
   def test_find_all_by_from_with_options
     ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.xml", {}, @people_david }
-  
+
     people = Person.find(:all, :from => "/companies/1/people.xml")
     assert_equal 1, people.size
     assert_equal "David", people.first.name
@@ -572,7 +592,7 @@ class BaseTest < Test::Unit::TestCase
 
   def test_find_all_by_symbol_from
     ActiveResource::HttpMock.respond_to { |m| m.get "/people/managers.xml", {}, @people_david }
-  
+
     people = Person.find(:all, :from => :managers)
     assert_equal 1, people.size
     assert_equal "David", people.first.name
@@ -601,10 +621,10 @@ class BaseTest < Test::Unit::TestCase
   def test_id_from_response
     p = Person.new
     resp = {'Location' => '/foo/bar/1'}
-    assert_equal '1', p.send!(:id_from_response, resp)
-    
+    assert_equal '1', p.__send__(:id_from_response, resp)
+
     resp['Location'] << '.xml'
-    assert_equal '1', p.send!(:id_from_response, resp)
+    assert_equal '1', p.__send__(:id_from_response, resp)
   end
 
   def test_create_with_custom_prefix
@@ -619,16 +639,16 @@ class BaseTest < Test::Unit::TestCase
     ryan = Person.new(:id => 1, :name => 'Ryan', :address => address)
     assert_equal address.prefix_options, ryan.address.prefix_options
   end
-  
+
   def test_reload_works_with_prefix_options
     address = StreetAddress.find(1, :params => { :person_id => 1 })
     assert_equal address, address.reload
   end
-  
+
   def test_reload_with_redefined_to_param
     Person.module_eval do
       alias_method :original_to_param_reload, :to_param
-       def to_param  
+       def to_param
          name
        end
     end
@@ -643,13 +663,13 @@ class BaseTest < Test::Unit::TestCase
         alias_method :reload_to_param, :to_param
         alias_method :to_param, :original_to_param_reload
       end
-  end  
-  
-  def test_reload_works_without_prefix_options    
+  end
+
+  def test_reload_works_without_prefix_options
     person = Person.find(:first)
     assert_equal person, person.reload
   end
-    
+
 
   def test_create
     rick = Person.create(:name => 'Rick')
@@ -659,11 +679,11 @@ class BaseTest < Test::Unit::TestCase
 
     # test additional attribute returned on create
     assert_equal 25, rick.age
-    
+
     # Test that save exceptions get bubbled up too
     ActiveResource::HttpMock.respond_to do |mock|
       mock.post   "/people.xml", {}, nil, 409
-    end    
+    end
     assert_raises(ActiveResource::ResourceConflict) { Person.create(:name => 'Rick') }
   end
 
@@ -725,7 +745,7 @@ class BaseTest < Test::Unit::TestCase
     assert_equal "54321 Lane", addy.street
     addy.save
   end
-  
+
   def test_update_conflict
     ActiveResource::HttpMock.respond_to do |mock|
       mock.get "/people/2.xml", {}, @david
@@ -757,7 +777,7 @@ class BaseTest < Test::Unit::TestCase
     end
     assert_raises(ActiveResource::ResourceNotFound) { Person.find(1) }
   end
-  
+
   def test_delete_with_custom_prefix
     assert StreetAddress.delete(1, :person_id => 1)
     ActiveResource::HttpMock.respond_to do |mock|
@@ -787,23 +807,23 @@ class BaseTest < Test::Unit::TestCase
     assert !StreetAddress.new({:id => 1, :person_id => 2}).exists?
     assert !StreetAddress.new({:id => 2, :person_id => 1}).exists?
   end
-  
+
   def test_exists_with_redefined_to_param
     Person.module_eval do
       alias_method :original_to_param_exists, :to_param
-       def to_param  
+       def to_param
          name
        end
     end
 
     # Class method.
-    assert Person.exists?('Greg')    
+    assert Person.exists?('Greg')
 
     # Instance method.
-    assert Person.find('Greg').exists?    
+    assert Person.find('Greg').exists?
 
     # Nested class method.
-    assert StreetAddress.exists?(1,  :params => { :person_id => Person.find('Greg').to_param })    
+    assert StreetAddress.exists?(1,  :params => { :person_id => Person.find('Greg').to_param })
 
     # Nested instance method.
     assert StreetAddress.find(1, :params => { :person_id => Person.find('Greg').to_param }).exists?
@@ -815,11 +835,11 @@ class BaseTest < Test::Unit::TestCase
         alias_method :exists_to_param, :to_param
         alias_method :to_param, :original_to_param_exists
       end
-  end  
-  
+  end
+
   def test_to_xml
     matz = Person.find(1)
-    xml = matz.to_xml
+    xml = matz.encode
     assert xml.starts_with?('<?xml version="1.0" encoding="UTF-8"?>')
     assert xml.include?('<name>Matz</name>')
     assert xml.include?('<id type="integer">1</id>')
@@ -845,4 +865,14 @@ class BaseTest < Test::Unit::TestCase
       end
     end
   end
+
+  def test_load_yaml_array
+    assert_nothing_raised do
+      marty = Person.find(5)
+      assert_equal 3, marty.colors.size
+      marty.colors.each do |color|
+        assert_kind_of String, color
+      end
+    end
+  end
 end