activeresource 2.3.18 → 3.0.0.beta

data/CHANGELOG

@@ -1,27 +1,4 @@
-*2.3.11 (February 9, 2011)*
-*2.3.10 (October 15, 2010)*
-*2.3.9 (September 4, 2010)*
-*2.3.8 (May 24, 2010)*
-*2.3.7 (May 24, 2010)*
-
-* Version bump.
-
-
-*2.3.6 (May 23, 2010)*
-
-* No changes, just a version bump.
-
-
-*2.3.5 (November 25, 2009)*
-
-* Minor Bug Fixes and deprecation warnings
-
-* More flexible content type handling when parsing responses.
-  
-  Ensures that ARes will handle responses like test/xml, or content types
-  with charsets included.
-
-*2.3.4 (September 4, 2009)*
+*Edge*
 
 * Add support for errors in JSON format.  #1956 [Fabien Jakimowicz]
 
@@ -32,11 +9,6 @@
 * HTTP proxy support.  #2133 [Marshall Huss, Sébastien Dabet]
 
 
-*2.3.3 (July 12, 2009)*
-
-* No changes, just a version bump.
-
-
 *2.3.2 [Final] (March 15, 2009)*
 
 * Nothing new, just included in 2.3.2

data/README

@@ -1,7 +1,7 @@
 = Active Resource
 
 Active Resource (ARes) connects business objects and Representational State Transfer (REST)
-web services.  It implements object-relational mapping for REST webservices to provide transparent 
+web services.  It implements object-relational mapping for REST web services to provide transparent
 proxying capabilities between a client (ActiveResource) and a RESTful service (which is provided by Simply RESTful routing
 in ActionController::Resources).
 
@@ -22,14 +22,14 @@ received and serialized into a usable Ruby object.
 
 === Configuration and Usage
 
-Putting ActiveResource to use is very similar to ActiveRecord.  It's as simple as creating a model class
+Putting Active Resource to use is very similar to Active Record.  It's as simple as creating a model class
 that inherits from ActiveResource::Base and providing a <tt>site</tt> class variable to it:
 
    class Person < ActiveResource::Base
      self.site = "http://api.people.com:3000/"
    end
 
-Now the Person class is REST enabled and can invoke REST services very similarly to how ActiveRecord invokes
+Now the Person class is REST enabled and can invoke REST services very similarly to how Active Record invokes
 lifecycle methods that operate against a persistent store.
 
    # Find a person with id = 1
@@ -42,7 +42,7 @@ records.  But rather than dealing directly with a database record, you're dealin
 ==== Protocol
 
 Active Resource is built on a standard XML format for requesting and submitting resources over HTTP.  It mirrors the RESTful routing 
-built into ActionController but will also work with any other REST service that properly implements the protocol. 
+built into Action Controller but will also work with any other REST service that properly implements the protocol.
 REST uses HTTP, but unlike "typical" web applications, it makes use of all the verbs available in the HTTP specification:
 
 * GET requests are used for finding and retrieving resources.
@@ -55,8 +55,8 @@ for more general information on REST web services, see the article here[http://e
 
 ==== Find
 
-GET Http requests expect the XML form of whatever resource/resources is/are being requested.  So,
-for a request for a single element - the XML of that item is expected in response:
+Find requests use the GET method and expect the XML form of whatever resource/resources is/are being requested.  So,
+for a request for a single element, the XML of that item is expected in response:
 
    # Expects a response of
    #
@@ -101,7 +101,7 @@ Collections can also be requested in a similar fashion
 
 ==== Create
 
-Creating a new resource submits the xml form of the resource as the body of the request and expects
+Creating a new resource submits the XML form of the resource as the body of the request and expects
 a 'Location' header in the response with the RESTful URL location of the newly created resource.  The
 id of the newly created resource is parsed out of the Location response header and automatically set
 as the id of the ARes object.

data/examples/simple.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'active_resource'
+require 'active_support/core_ext/hash/conversions'
+
+ActiveSupport::XmlMini.backend = ENV['XMLMINI'] || 'REXML'
+ActiveResource::HttpMock.respond_to do |mock|
+  mock.get '/people/1.xml', {}, { :id => 1, :name => 'bob' }.to_xml(:root => 'person')
+end
+
+class Person < ActiveResource::Base
+  self.site = 'http://localhost/'
+end
+
+bob = Person.find(1)
+puts bob.inspect

data/lib/active_resource.rb

@@ -21,24 +21,24 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'active_support'
-rescue LoadError
-  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
-  if File.directory?(activesupport_path)
-    $:.unshift activesupport_path
-    require 'active_support'
-  end
-end
+activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
+$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+
+activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
+$:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
 
-require 'active_resource/formats'
-require 'active_resource/base'
-require 'active_resource/validations'
-require 'active_resource/custom_methods'
+require 'active_support'
+require 'active_model'
 
 module ActiveResource
-  Base.class_eval do
-    include Validations
-    include CustomMethods
-  end
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Connection
+  autoload :CustomMethods
+  autoload :Formats
+  autoload :HttpMock
+  autoload :Observing
+  autoload :Schema
+  autoload :Validations
 end

data/lib/active_resource/base.rb

@@ -1,6 +1,21 @@
-require 'active_resource/connection'
-require 'cgi'
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/module/attr_accessor_with_default'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/misc'
+require 'active_support/core_ext/object/to_query'
 require 'set'
+require 'uri'
+
+require 'active_resource/exceptions'
+require 'active_resource/connection'
+require 'active_resource/formats'
+require 'active_resource/schema'
 
 module ActiveResource
   # ActiveResource::Base is the main class for mapping RESTful resources as models in a Rails application.
@@ -19,7 +34,7 @@ module ActiveResource
   #   end
   #
   # Now the Person class is mapped to RESTful resources located at <tt>http://api.people.com:3000/people/</tt>, and
-  # you can now use Active Resource's lifecycles methods to manipulate resources. In the case where you already have
+  # you can now use Active Resource's lifecycle methods to manipulate resources. In the case where you already have
   # an existing model with the same name as the desired RESTful resource you can set the +element_name+ value.
   #
   #   class PersonResource < ActiveResource::Base
@@ -27,6 +42,13 @@ module ActiveResource
   #     self.element_name = "person"
   #   end
   #
+  # If your Active Resource object is required to use an HTTP proxy you can set the +proxy+ value which holds a URI.
+  #
+  #   class PersonResource < ActiveResource::Base
+  #     self.site = "http://api.people.com:3000/"
+  #     self.proxy = "http://user:password@proxy.people.com:8080"
+  #   end
+  #
   #
   # == Lifecycle methods
   #
@@ -127,6 +149,7 @@ module ActiveResource
   #                          :verify_mode  => OpenSSL::SSL::VERIFY_PEER}
   #    end
   #
+  #
   # == Errors & Validation
   #
   # Error handling and validation is handled in much the same manner as you're used to seeing in
@@ -144,7 +167,7 @@ module ActiveResource
   #
   # <tt>404</tt> is just one of the HTTP error response codes that Active Resource will handle with its own exception. The
   # following HTTP response codes will also result in these exceptions:
-  # 
+  #
   # * 200..399 - Valid response, no exception (other than 301, 302)
   # * 301, 302 - ActiveResource::Redirection
   # * 400 - ActiveResource::BadRequest
@@ -172,7 +195,7 @@ module ActiveResource
   #
   # === Validation errors
   #
-  # Active Resource supports validations on resources and will return errors if any these validations fail
+  # Active Resource supports validations on resources and will return errors if any of these validations fail
   # (e.g., "First name can not be blank" and so on).  These types of errors are denoted in the response by
   # a response code of <tt>422</tt> and an XML or JSON representation of the validation errors.  The save operation will
   # then fail (with a <tt>false</tt> return value) and the validation errors can be accessed on the resource in question.
@@ -227,10 +250,125 @@ module ActiveResource
     # The logger for diagnosing and tracing Active Resource calls.
     cattr_accessor :logger
 
-    # Controls the top-level behavior of JSON serialization
-    cattr_accessor :include_root_in_json, :instance_writer => false
-
     class << self
+      # Creates a schema for this resource - setting the attributes that are
+      # known prior to fetching an instance from the remote system.
+      #
+      # The schema helps define the set of <tt>known_attributes</tt> of the
+      # current resource.
+      #
+      # There is no need to specify a schema for your Active Resource. If
+      # you do not, the <tt>known_attributes</tt> will be guessed from the
+      # instance attributes returned when an instance is fetched from the
+      # remote system.
+      #
+      # example:
+      # class Person < ActiveResource::Base
+      #   schema do
+      #     # define each attribute separately
+      #     attribute 'name', :string
+      #
+      #     # or use the convenience methods and pass >=1 attribute names
+      #     string  'eye_colour', 'hair_colour'
+      #     integer 'age'
+      #     float   'height', 'weight'
+      #
+      #     # unsupported types should be left as strings
+      #     # overload the accessor methods if you need to convert them
+      #     attribute 'created_at', 'string'
+      #   end
+      # end
+      #
+      # p = Person.new
+      # p.respond_to? :name   # => true
+      # p.respond_to? :age    # => true
+      # p.name                # => nil
+      # p.age                 # => nil
+      #
+      # j = Person.find_by_name('John') # <person><name>John</name><age>34</age><num_children>3</num_children></person>
+      # j.respond_to? :name   # => true
+      # j.respond_to? :age    # => true
+      # j.name                # => 'John'
+      # j.age                 # => '34'  # note this is a string!
+      # j.num_children        # => '3'  # note this is a string!
+      #
+      # p.num_children        # => NoMethodError
+      #
+      # Attribute-types must be one of:
+      #  string, integer, float
+      #
+      # Note: at present the attribute-type doesn't do anything, but stay
+      # tuned...
+      # Shortly it will also *cast* the value of the returned attribute.
+      # ie:
+      # j.age                 # => 34   # cast to an integer
+      # j.weight              # => '65' # still a string!
+      #
+      def schema(&block)
+        if block_given?
+          schema_definition = Schema.new
+          schema_definition.instance_eval(&block)
+
+          # skip out if we didn't define anything
+          return unless schema_definition.attrs.present?
+
+          @schema ||= {}.with_indifferent_access
+          @known_attributes ||= []
+
+          schema_definition.attrs.each do |k,v|
+            @schema[k] = v
+            @known_attributes << k
+          end
+
+          schema
+        else
+          @schema ||= nil
+        end
+      end
+
+      # Alternative, direct way to specify a <tt>schema</tt> for this
+      # Resource. <tt>schema</tt> is more flexible, but this is quick
+      # for a very simple schema.
+      #
+      # Pass the schema as a hash with the keys being the attribute-names
+      # and the value being one of the accepted attribute types (as defined
+      # in <tt>schema</tt>)
+      #
+      # example:
+      #
+      # class Person < ActiveResource::Base
+      #   schema = {'name' => :string, 'age' => :integer }
+      # end
+      #
+      # The keys/values can be strings or symbols. They will be converted to
+      # strings.
+      #
+      def schema=(the_schema)
+        unless the_schema.present?
+          # purposefully nulling out the schema
+          @schema = nil
+          @known_attributes = []
+          return
+        end
+
+        raise ArgumentError, "Expected a hash" unless the_schema.kind_of? Hash
+
+        schema do
+          the_schema.each {|k,v| attribute(k,v) }
+        end
+      end
+
+      # Returns the list of known attributes for this resource, gathered
+      # from the provided <tt>schema</tt>
+      # Attributes that are known will cause your resource to return 'true'
+      # when <tt>respond_to?</tt> is called on them. A known attribute will
+      # return nil if not set (rather than <t>MethodNotFound</tt>); thus
+      # known attributes can be used with <tt>validates_presence_of</tt>
+      # without a getter-method.
+      def known_attributes
+        @known_attributes ||= []
+      end
+
       # Gets the URI of the REST resources to map for this class.  The site variable is required for
       # Active Resource's mapping to work.
       def site
@@ -264,8 +402,8 @@ module ActiveResource
           @site = nil
         else
           @site = create_site_uri_from(site)
-          @user = URI.decode(@site.user) if @site.user
-          @password = URI.decode(@site.password) if @site.password
+          @user = uri_parser.unescape(@site.user) if @site.user
+          @password = uri_parser.unescape(@site.password) if @site.password
         end
       end
 
@@ -317,6 +455,17 @@ module ActiveResource
         @password = password
       end
 
+      def auth_type
+        if defined?(@auth_type)
+          @auth_type
+        end
+      end
+
+      def auth_type=(auth_type)
+        @connection = nil
+        @auth_type = auth_type
+      end
+
       # Sets the format that attributes are sent and received in from a mime type reference:
       #
       #   Person.format = :json
@@ -336,7 +485,7 @@ module ActiveResource
 
       # Returns the current format, default is ActiveResource::Formats::XmlFormat.
       def format
-        read_inheritable_attribute(:format) || ActiveResource::Formats[:xml]
+        read_inheritable_attribute(:format) || ActiveResource::Formats::XmlFormat
       end
 
       # Sets the number of seconds after which requests to the REST API should time out.
@@ -388,6 +537,7 @@ module ActiveResource
           @connection.proxy = proxy if proxy
           @connection.user = user if user
           @connection.password = password if password
+          @connection.auth_type = auth_type if auth_type
           @connection.timeout = timeout if timeout
           @connection.ssl_options = ssl_options if ssl_options
           @connection
@@ -402,11 +552,11 @@ module ActiveResource
 
       # Do not include any modules in the default element name. This makes it easier to seclude ARes objects
       # in a separate namespace without having to set element_name repeatedly.
-      attr_accessor_with_default(:element_name)    { to_s.split("::").last.underscore } #:nodoc:
+      attr_accessor_with_default(:element_name)    { ActiveSupport::Inflector.underscore(to_s.split("::").last) } #:nodoc:
 
-      attr_accessor_with_default(:collection_name) { element_name.pluralize } #:nodoc:
+      attr_accessor_with_default(:collection_name) { ActiveSupport::Inflector.pluralize(element_name) } #:nodoc:
       attr_accessor_with_default(:primary_key, 'id') #:nodoc:
-      
+
       # Gets the \prefix for a resource's nested URL (e.g., <tt>prefix/collectionname/1.xml</tt>)
       # This method is regenerated at runtime based on what the \prefix is set to.
       def prefix(options={})
@@ -434,13 +584,13 @@ module ActiveResource
         @prefix_parameters = nil
 
         # Redefine the new methods.
-        code, line = <<-end_code, __LINE__ + 1
+        code = <<-end_code
           def prefix_source() "#{value}" end
           def prefix(options={}) "#{prefix_call}" end
         end_code
-        silence_warnings { instance_eval code, __FILE__, line }
+        silence_warnings { instance_eval code, __FILE__, __LINE__ }
       rescue
-        logger.error "Couldn't set prefix: #{$!}\n  #{code}"
+        logger.error "Couldn't set prefix: #{$!}\n  #{code}" if logger
         raise
       end
 
@@ -479,7 +629,7 @@ module ActiveResource
       # will split from the +prefix_options+.
       #
       # ==== Options
-      # * +prefix_options+ - A hash to add a prefix to the request for nested URL's (e.g., <tt>:account_id => 19</tt>
+      # * +prefix_options+ - A hash to add a prefix to the request for nested URLs (e.g., <tt>:account_id => 19</tt>
       #   would yield a URL like <tt>/accounts/19/purchases.xml</tt>).
       # * +query_options+ - A hash to add items to the query string for the request.
       #
@@ -577,6 +727,19 @@ module ActiveResource
       #
       #   StreetAddress.find(1, :params => { :person_id => 1 })
       #   # => GET /people/1/street_addresses/1.xml
+      #
+      # == Failure or missing data
+      #   A failure to find the requested object raises a ResourceNotFound
+      #   exception if the find was called with an id.
+      #   With any other scope, find returns nil when no data is returned.
+      #
+      #   Person.find(1)
+      #   # => raises ResourcenotFound
+      #
+      #   Person.find(:all)
+      #   Person.find(:first)
+      #   Person.find(:last)
+      #   # => nil
       def find(*arguments)
         scope   = arguments.slice!(0)
         options = arguments.slice!(0) || {}
@@ -590,6 +753,28 @@ module ActiveResource
         end
       end
 
+
+      # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass
+      # in all the same arguments to this method as you can to
+      # <tt>find(:first)</tt>.
+      def first(*args)
+        find(:first, *args)
+      end
+
+      # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass
+      # in all the same arguments to this method as you can to
+      # <tt>find(:last)</tt>.
+      def last(*args)
+        find(:last, *args)
+      end
+
+      # This is an alias for find(:all).  You can pass in all the same
+      # arguments to this method as you can to <tt>find(:all)</tt>
+      def all(*args)
+        find(:all, *args)
+      end
+
+
       # Deletes the resources with the ID in the +id+ parameter.
       #
       # ==== Options
@@ -630,16 +815,22 @@ module ActiveResource
       private
         # Find every resource
         def find_every(options)
-          case from = options[:from]
-          when Symbol
-            instantiate_collection(get(from, options[:params]))
-          when String
-            path = "#{from}#{query_string(options[:params])}"
-            instantiate_collection(connection.get(path, headers) || [])
-          else
-            prefix_options, query_options = split_options(options[:params])
-            path = collection_path(prefix_options, query_options)
-            instantiate_collection( (connection.get(path, headers) || []), prefix_options )
+          begin
+            case from = options[:from]
+            when Symbol
+              instantiate_collection(get(from, options[:params]))
+            when String
+              path = "#{from}#{query_string(options[:params])}"
+              instantiate_collection(connection.get(path, headers) || [])
+            else
+              prefix_options, query_options = split_options(options[:params])
+              path = collection_path(prefix_options, query_options)
+              instantiate_collection( (connection.get(path, headers) || []), prefix_options )
+            end
+          rescue ActiveResource::ResourceNotFound
+            # Swallowing ResourceNotFound exceptions and return nil - as per
+            # ActiveRecord.
+            nil
           end
         end
 
@@ -674,12 +865,12 @@ module ActiveResource
 
         # Accepts a URI and creates the site URI from that.
         def create_site_uri_from(site)
-          site.is_a?(URI) ? site.dup : URI.parse(site)
+          site.is_a?(URI) ? site.dup : uri_parser.parse(site)
         end
 
         # Accepts a URI and creates the proxy URI from that.
         def create_proxy_uri_from(proxy)
-          proxy.is_a?(URI) ? proxy.dup : URI.parse(proxy)
+          proxy.is_a?(URI) ? proxy.dup : uri_parser.parse(proxy)
         end
 
         # contains a set of the current prefix parameters.
@@ -704,11 +895,30 @@ module ActiveResource
 
           [ prefix_options, query_options ]
         end
+
+        def uri_parser
+          @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+        end
     end
 
     attr_accessor :attributes #:nodoc:
     attr_accessor :prefix_options #:nodoc:
 
+    # If no schema has been defined for the class (see
+    # <tt>ActiveResource::schema=</tt>), the default automatic schema is
+    # generated from the current instance's attributes
+    def schema
+      self.class.schema || self.attributes
+    end
+
+    # This is a list of known attributes for this resource. Either
+    # gathered fromthe provided <tt>schema</tt>, or from the attributes
+    # set on this instance after it has been fetched from the remote system.
+    def known_attributes
+      self.class.known_attributes + self.attributes.keys.map(&:to_s)
+    end
+
+
     # Constructor method for \new resources; the optional +attributes+ parameter takes a \hash
     # of attributes for the \new resource.
     #
@@ -721,7 +931,7 @@ module ActiveResource
     #   my_other_course = Course.new(:name => "Philosophy: Reason and Being", :lecturer => "Ralph Cling")
     #   my_other_course.save
     def initialize(attributes = {})
-      @attributes     = {}
+      @attributes     = {}.with_indifferent_access
       @prefix_options = {}
       load(attributes)
     end
@@ -762,7 +972,7 @@ module ActiveResource
     end
 
 
-    # A method to determine if the resource a \new object (i.e., it has not been POSTed to the remote service yet).
+    # Returns +true+ if this object hasn't yet been saved, otherwise, returns +false+.
     #
     # ==== Examples
     #   not_new = Computer.create(:brand => 'Apple', :make => 'MacBook', :vendor => 'MacMall')
@@ -831,7 +1041,7 @@ module ActiveResource
       id.hash
     end
 
-    # Duplicate the current resource without saving it.
+    # Duplicates the current resource without saving it.
     #
     # ==== Examples
     #   my_invoice = Invoice.create(:customer => 'That Company')
@@ -850,8 +1060,8 @@ module ActiveResource
       end
     end
 
-    # A method to \save (+POST+) or \update (+PUT+) a resource.  It delegates to +create+ if a \new object, 
-    # +update+ if it is existing. If the response to the \save includes a body, it will be assumed that this body
+    # Saves (+POST+) or \updates (+PUT+) a resource.  Delegates to +create+ if the object is \new,
+    # +update+ if it exists. If the response to the \save includes a body, it will be assumed that this body
     # is XML for the final object as it looked after the \save (which would include attributes like +created_at+
     # that weren't part of the original submit).
     #
@@ -867,6 +1077,23 @@ module ActiveResource
       new? ? create : update
     end
 
+    # Saves the resource.
+    #
+    # If the resource is new, it is created via +POST+, otherwise the
+    # existing resource is updated via +PUT+.
+    #
+    # With <tt>save!</tt> validations always run. If any of them fail
+    # ActiveResource::ResourceInvalid gets raised, and nothing is POSTed to
+    # the remote system.
+    # See ActiveResource::Validations for more information.
+    #
+    # There's a series of callbacks associated with <tt>save!</tt>. If any
+    # of the <tt>before_*</tt> callbacks return +false+ the action is
+    # cancelled and <tt>save!</tt> raises ActiveResource::ResourceInvalid.
+    def save!
+      save || raise(ResourceInvalid.new(self))
+    end
+
     # Deletes the resource from the remote service.
     #
     # ==== Examples
@@ -903,7 +1130,7 @@ module ActiveResource
       !new? && self.class.exists?(to_param, :params => prefix_options)
     end
 
-     # Converts the resource to an XML string representation.
+    # Converts the resource to an XML string representation.
     #
     # ==== Options
     # The +options+ parameter is handed off to the +to_xml+ method on each
@@ -912,14 +1139,7 @@ module ActiveResource
     #
     # * <tt>:indent</tt> - Set the indent level for the XML output (default is +2+).
     # * <tt>:dasherize</tt> - Boolean option to determine whether or not element names should
-    #   replace underscores with dashes. Default is <tt>true</tt>. The default can be set to <tt>false</tt>
-    #   by setting the module attribute <tt>ActiveSupport.dasherize_xml = false</tt> in an initializer. Because save
-    #   uses this method, and there are no options on save, then you will have to set the default if you don't
-    #   want underscores in element names to become dashes when the resource is saved. This is important when
-    #   integrating with non-Rails applications.
-    # * <tt>:camelize</tt> - Boolean option to determine whether or not element names should be converted
-    #   to camel case, e.g some_name to SomeName. Default is <tt>false</tt>. Like <tt>:dasherize</tt> you can
-    #   change the default by setting the module attribute <tt>ActiveSupport.camelise_xml = true</tt> in an initializer.
+    #   replace underscores with dashes (default is <tt>false</tt>).
     # * <tt>:skip_instruct</tt> - Toggle skipping the +instruct!+ call on the XML builder
     #   that generates the XML declaration (default is <tt>false</tt>).
     #
@@ -972,14 +1192,8 @@ module ActiveResource
     # applicable depend on the configured encoding format.
     def encode(options={})
       case self.class.format
-        when ActiveResource::Formats[:xml]
+        when ActiveResource::Formats::XmlFormat
           self.class.format.encode(attributes, {:root => self.class.element_name}.merge(options))
-        when ActiveResource::Formats::JsonFormat
-          if ActiveResource::Base.include_root_in_json
-            self.class.format.encode({self.class.element_name => attributes}, options)
-          else
-            self.class.format.encode(attributes, options)
-          end
         else
           self.class.format.encode(attributes, options)
       end
@@ -1046,6 +1260,36 @@ module ActiveResource
       self
     end
 
+    # Updates a single attribute and then saves the object.
+    #
+    # Note: Unlike ActiveRecord::Base.update_attribute, this method <b>is</b>
+    # subject to normal validation routines as an update sends the whole body
+    # of the resource in the request.  (See Validations).
+    #
+    # As such, this method is equivalent to calling update_attributes with a single attribute/value pair.
+    #
+    # If the saving fails because of a connection or remote service error, an
+    # exception will be raised.  If saving fails because the resource is
+    # invalid then <tt>false</tt> will be returned.
+    def update_attribute(name, value)
+      self.send("#{name}=".to_sym, value)
+      self.save
+    end
+
+    # Updates this resource with all the attributes from the passed-in Hash
+    # and requests that the record be saved.
+    #
+    # If the saving fails because of a connection or remote service error, an
+    # exception will be raised.  If saving fails because the resource is
+    # invalid then <tt>false</tt> will be returned.
+    #
+    # Note: Though this request can be made with a partial set of the
+    # resource's attributes, the full body of the request will still be sent
+    # in the save request to the remote service.
+    def update_attributes(attributes)
+      load(attributes) && save
+    end
+
     # For checking <tt>respond_to?</tt> without searching the attributes (which is faster).
     alias_method :respond_to_without_attributes?, :respond_to?
 
@@ -1055,18 +1299,18 @@ module ActiveResource
     def respond_to?(method, include_priv = false)
       method_name = method.to_s
       if attributes.nil?
-        return super
-      elsif attributes.has_key?(method_name)
-        return true
-      elsif ['?','='].include?(method_name.last) && attributes.has_key?(method_name.first(-1))
-        return true
+        super
+      elsif known_attributes.include?(method_name)
+        true
+      elsif method_name =~ /(?:=|\?)$/ && attributes.include?($`)
+        true
+      else
+        # super must be called at the end of the method, because the inherited respond_to?
+        # would return true for generated readers, even if the attribute wasn't present
+        super
       end
-      # super must be called at the end of the method, because the inherited respond_to?
-      # would return true for generated readers, even if the attribute wasn't present
-      super
     end
 
-
     protected
       def connection(refresh = false)
         self.class.connection(refresh)
@@ -1109,7 +1353,7 @@ module ActiveResource
     private
       # Tries to find a resource for a given collection name; if it fails, then the resource is created
       def find_or_create_resource_for_collection(name)
-        find_or_create_resource_for(name.to_s.singularize)
+        find_or_create_resource_for(ActiveSupport::Inflector.singularize(name.to_s))
       end
 
       # Tries to find a resource in a non empty list of nested modules
@@ -1153,14 +1397,24 @@ module ActiveResource
       def method_missing(method_symbol, *arguments) #:nodoc:
         method_name = method_symbol.to_s
 
-        case method_name.last
+        if method_name =~ /(=|\?)$/
+          case $1
           when "="
-            attributes[method_name.first(-1)] = arguments.first
+            attributes[$`] = arguments.first
           when "?"
-            attributes[method_name.first(-1)]
-          else
-            attributes.has_key?(method_name) ? attributes[method_name] : super
+            attributes[$`]
+          end
+        else
+          return attributes[method_name] if attributes.include?(method_name)
+          # not set right now but we know about it
+          return nil if known_attributes.include?(method_name)
+          super
         end
       end
   end
+
+  class Base
+    extend ActiveModel::Naming
+    include CustomMethods, Observing, Validations
+  end
 end