Module: ActiveResource::CustomMethods

### Home Classes Methods

### In Files

- lib/active_resource/custom_methods.rb

### Namespace

- MODULE ActiveResource::CustomMethods::ClassMethods

### Methods

- ::delete
- ::get
- ::orig_delete
- ::post
- ::put
- #delete
- #get
- #post
- #put

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- ActiveResource
- ActiveResource::Base
- ActiveResource::Connection
- ActiveResource::CustomMethods
- ActiveResource::CustomMethods::ClassMethods
- ActiveResource::Errors
- ActiveResource::Formats
- ActiveResource::Formats::JsonFormat
- ActiveResource::Formats::XmlFormat
- ActiveResource::HttpMock
- ActiveResource::InvalidRequestError
- ActiveResource::LogSubscriber
- ActiveResource::Observing
- ActiveResource::Railtie
- ActiveResource::Request
- ActiveResource::Response
- ActiveResource::SSLError
- ActiveResource::TimeoutError
- ActiveResource::Validations

No matching classes.

# ActiveResource::CustomMethods

A module to support custom REST methods and sub-resources, allowing you to break out of the "default" REST methods with your own custom resource requests. For example, say you use Rails to expose a REST service and configure your routes with:

      map.resources :people, :new => { :register => :post },
                             :member => { :promote => :put, :deactivate => :delete }
                             :collection => { :active => :get }

    This route set creates routes for the following HTTP requests:

      POST    /people/new/register.json # PeopleController.register
      PUT     /people/1/promote.json    # PeopleController.promote with :id => 1
      DELETE  /people/1/deactivate.json # PeopleController.deactivate with :id => 1
      GET     /people/active.json       # PeopleController.active

Using this module, Active Resource can use these custom REST methods just like the standard methods.

    class Person < ActiveResource::Base
      self.site = "http://37s.sunrise.i:3000"
    end

    Person.new(:name => 'Ryan').post(:register)  # POST /people/new/register.json
    # => { :id => 1, :name => 'Ryan' }

    Person.find(1).put(:promote, :position => 'Manager') # PUT /people/1/promote.json
    Person.find(1).delete(:deactivate) # DELETE /people/1/deactivate.json

    Person.get(:active)  # GET /people/active.json
    # => [{:id => 1, :name => 'Ryan'}, {:id => 2, :name => 'Joe'}]

### Public Class Methods

delete(custom_method_name, options = {}) click to toggle source

    # File lib/active_resource/custom_methods.rb, line 70
    def delete(custom_method_name, options = {})
      # Need to jump through some hoops to retain the original class 'delete' method
      if custom_method_name.is_a?(Symbol)
        connection.delete(custom_method_collection_url(custom_method_name, options), headers)
      else
        orig_delete(custom_method_name, options)
      end
    end

Also aliased as: orig_delete
get(custom_method_name, options = {}) click to toggle source

Invokes a GET to a given custom REST method. For example:

    Person.get(:active)  # GET /people/active.json
    # => [{:id => 1, :name => 'Ryan'}, {:id => 2, :name => 'Joe'}]

    Person.get(:active, :awesome => true)  # GET /people/active.json?awesome=true
    # => [{:id => 1, :name => 'Ryan'}]

Note: the objects returned from this method are not automatically converted into ActiveResource::Base instances - they are ordinary Hashes. If you are expecting ActiveResource::Base instances, use the `find` class method with the `:from` option. For example:

    Person.find(:all, :from => :active)

    # File lib/active_resource/custom_methods.rb, line 56
    def get(custom_method_name, options = {})
      hashified = format.decode(connection.get(custom_method_collection_url(custom_method_name, options), headers).body)
      derooted  = Formats.remove_root(hashified)
      derooted.is_a?(Array) ? derooted.map { |e| Formats.remove_root(e) } : derooted
    end

orig_delete(custom_method_name, options = {}) click to toggle source
Alias for: delete
post(custom_method_name, options = {}, body = '') click to toggle source

    # File lib/active_resource/custom_methods.rb, line 62
    def post(custom_method_name, options = {}, body = '')
      connection.post(custom_method_collection_url(custom_method_name, options), body, headers)
    end

put(custom_method_name, options = {}, body = '') click to toggle source

    # File lib/active_resource/custom_methods.rb, line 66
    def put(custom_method_name, options = {}, body = '')
      connection.put(custom_method_collection_url(custom_method_name, options), body, headers)
    end

### Public Instance Methods

delete(method_name, options = {}) click to toggle source

    # File lib/active_resource/custom_methods.rb, line 105
    def delete(method_name, options = {})
      connection.delete(custom_method_element_url(method_name, options), self.class.headers)
    end

get(method_name, options = {}) click to toggle source

    # File lib/active_resource/custom_methods.rb, line 88
    def get(method_name, options = {})
      self.class.format.decode(connection.get(custom_method_element_url(method_name, options), self.class.headers).body)
    end

post(method_name, options = {}, body = nil) click to toggle source

    # File lib/active_resource/custom_methods.rb, line 92
    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), request_body, self.class.headers)
      else
        connection.post(custom_method_element_url(method_name, options), request_body, self.class.headers)
      end
    end

put(method_name, options = {}, body = '') click to toggle source

    # File lib/active_resource/custom_methods.rb, line 101
    def put(method_name, options = {}, body = '')
      connection.put(custom_method_element_url(method_name, options), body, self.class.headers)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.