Module: ActiveResource::Validations

### Home Classes Methods

### In Files

- lib/active_resource/validations.rb

### Methods

- #errors
- #save_with_validation
- #valid?

### Included Modules

- ActiveModel::Validations

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- ActiveResource
- ActiveResource::BadRequest
- ActiveResource::Base
- ActiveResource::ClientError
- ActiveResource::Connection
- ActiveResource::CustomMethods
- ActiveResource::CustomMethods::ClassMethods
- ActiveResource::CustomMethods::InstanceMethods
- ActiveResource::Errors
- ActiveResource::ForbiddenAccess
- ActiveResource::Formats
- ActiveResource::Formats::JsonFormat
- ActiveResource::Formats::XmlFormat
- ActiveResource::HttpMock
- ActiveResource::InvalidRequestError
- ActiveResource::LogSubscriber
- ActiveResource::Observing
- ActiveResource::Railtie
- ActiveResource::Request
- ActiveResource::ResourceConflict
- ActiveResource::ResourceGone
- ActiveResource::ResourceNotFound
- ActiveResource::Response
- ActiveResource::SSLError
- ActiveResource::ServerError
- ActiveResource::TimeoutError
- ActiveResource::UnauthorizedAccess
- ActiveResource::Validations

No matching classes.

# ActiveResource::Validations

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

Consider a Person resource on the server requiring both a `first_name` and a `last_name` with a `validates_presence_of :first_name, :last_name` declaration in the model:

    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[:last_name]  # => ["can't be empty"]
    person.last_name = "Halpert"
    person.save                   # => true (and person is now saved to the remote service)

### Public Instance Methods

errors() click to toggle source

Returns the Errors object that holds all information about attribute error messages.

    # File lib/active_resource/validations.rb, line 138
    def errors
      @errors ||= Errors.new(self)
    end

save_with_validation(options=nil) click to toggle source

Validate a resource and save (POST) it to the remote web service. If any local validations fail - the save (POST) will not be attempted.

    # File lib/active_resource/validations.rb, line 71
    def save_with_validation(options=nil)
      perform_validation = case options
        when Hash
          options[:validate] != false
        when NilClass
          true
        else
          ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
          options
      end

      # clear the remote validations so they don't interfere with the local
      # ones. Otherwise we get an endless loop and can never change the
      # fields so as to make the resource valid
      @remote_errors = nil
      if perform_validation && valid? || !perform_validation
        save_without_validation
        true
      else
        false
      end
    rescue ResourceInvalid => error
      # cache the remote errors because every call to <tt>valid?</tt> clears
      # all errors. We must keep a copy to add these back after local
      # validations
      @remote_errors = error
      load_remote_errors(@remote_errors, true)
      false
    end

valid?() click to toggle source

Checks for errors on an object (i.e., is resource.errors empty?).

Runs all the specified local validations and returns true if no errors were added, otherwise false. Runs local validations (eg those on your Active Resource model), and also any errors returned from the remote system the last time we saved. Remote errors can only be cleared by trying to re-save the resource.

#### Examples

    my_person = Person.create(params[:person])
    my_person.valid?
    # => true

    my_person.errors.add('login', 'can not be empty') if my_person.login == ''
    my_person.valid?
    # => false

    # File lib/active_resource/validations.rb, line 131
    def valid?
      super
      load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?
      errors.empty?
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.