all(*args)
click to toggle source
This is an alias for find(:all). You can pass in all the same arguments to
this method as you can to find(:all)
def all(*args)
find(:all, *args)
end
auth_type()
click to toggle source
def auth_type
if defined?(@auth_type)
@auth_type
end
end
auth_type=(auth_type)
click to toggle source
def auth_type=(auth_type)
@connection = nil
@auth_type = auth_type
end
build(attributes = {})
click to toggle source
Builds a new, unsaved record using the default values from the remote
server so that it can be used with RESTful forms.
Options¶ ↑
Returns the new resource instance.
def build(attributes = {})
attrs = self.format.decode(connection.get("#{new_element_path(attributes)}", headers).body)
self.new(attrs)
end
collection_name()
click to toggle source
def collection_name
@collection_name ||= ActiveSupport::Inflector.pluralize(element_name)
end
collection_parser()
click to toggle source
def collection_parser
self._collection_parser || ActiveResource::Collection
end
collection_parser=(parser_instance)
click to toggle source
Sets the parser to use when a collection is returned. The parser must be
Enumerable.
def collection_parser=(parser_instance)
parser_instance = parser_instance.constantize if parser_instance.is_a?(String)
self._collection_parser = parser_instance
end
collection_path(prefix_options = {}, query_options = nil)
click to toggle source
Gets the collection path for the REST resources. If the
query_options
parameter is omitted, Rails will split from the
prefix_options
.
Options¶ ↑
-
prefix_options
- A hash to add a prefix to the request for
nested URLs (e.g., :account_id => 19
would yield a URL like
/accounts/19/purchases.json
).
-
query_options
- A hash to add items to the query string for
the request.
Examples¶ ↑
Post.collection_path
Comment.collection_path(:post_id => 5)
Comment.collection_path(:post_id => 5, :active => 1)
Comment.collection_path({:post_id => 5}, {:active => 1})
def collection_path(prefix_options = {}, query_options = nil)
check_prefix_options(prefix_options)
prefix_options, query_options = split_options(prefix_options) if query_options.nil?
"#{prefix(prefix_options)}#{collection_name}#{format_extension}#{query_string(query_options)}"
end
connection(refresh = false)
click to toggle source
An instance of ActiveResource::Connection
that is the base connection to the remote service. The refresh
parameter toggles whether or not the connection is refreshed at every
request or not (defaults to false
).
def connection(refresh = false)
if defined?(@connection) || superclass == Object
@connection = Connection.new(site, format) if refresh || @connection.nil?
@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
else
superclass.connection
end
end
create(attributes = {})
click to toggle source
Creates a new resource instance and makes a request to the remote service
that it be saved, making it equivalent to the following simultaneous calls:
ryan = Person.new(:first => 'ryan')
ryan.save
Returns the newly created resource. If a failure has occurred an exception
will be raised (see save
). If the resource is invalid and has
not been saved then valid?
will return false
,
while new?
will still return true
.
Examples¶ ↑
Person.create(:name => 'Jeremy', :email => 'myname@nospam.com', :enabled => true)
my_person = Person.find(:first)
my_person.email
dhh = Person.create(:name => 'David', :email => 'dhh@nospam.com', :enabled => true)
dhh.valid?
dhh.new?
that_guy = Person.create(:name => '', :email => 'thatguy@nospam.com', :enabled => true)
that_guy.valid?
that_guy.new?
def create(attributes = {})
self.new(attributes).tap { |resource| resource.save }
end
delete(id, options = {})
click to toggle source
Deletes the resources with the ID in the id
parameter.
Options¶ ↑
All options specify prefix and query parameters.
Examples¶ ↑
Event.delete(2)
Event.create(:name => 'Free Concert', :location => 'Community Center')
my_event = Event.find(:first)
Event.delete(my_event.id)
Event.delete(params[:id])
def delete(id, options = {})
connection.delete(element_path(id, options), headers)
end
element_name()
click to toggle source
def element_name
@element_name ||= model_name.element
end
element_path(id, prefix_options = {}, query_options = nil)
click to toggle source
Gets the element path for the given ID in id
. If the
query_options
parameter is omitted, Rails will split from the
prefix options.
Options¶ ↑
prefix_options
- A hash to add a prefix to the request for
nested URLs (e.g., :account_id => 19
would yield a URL like
/accounts/19/purchases.json
).
query_options
- A hash to add items to the query string for
the request.
Examples¶ ↑
Post.element_path(1)
class Comment < ActiveResource::Base
self.site = "https://37s.sunrise.com/posts/:post_id"
end
Comment.element_path(1, :post_id => 5)
Comment.element_path(1, :post_id => 5, :active => 1)
Comment.element_path(1, {:post_id => 5}, {:active => 1})
def element_path(id, prefix_options = {}, query_options = nil)
check_prefix_options(prefix_options)
prefix_options, query_options = split_options(prefix_options) if query_options.nil?
"#{prefix(prefix_options)}#{collection_name}/#{URI.parser.escape id.to_s}#{format_extension}#{query_string(query_options)}"
end
exists?(id, options = {})
click to toggle source
Asserts the existence of a resource, returning true
if the
resource is found.
Examples¶ ↑
Note.create(:title => 'Hello, world.', :body => 'Nothing more for now...')
Note.exists?(1)
Note.exists(1349)
def exists?(id, options = {})
if id
prefix_options, query_options = split_options(options[:params])
path = element_path(id, prefix_options, query_options)
response = connection.head(path, headers)
response.code.to_i == 200
end
rescue ActiveResource::ResourceNotFound, ActiveResource::ResourceGone
false
end
find(*arguments)
click to toggle source
Core method for finding resources. Used similarly to Active Record's
find
method.
Arguments¶ ↑
The first argument is considered to be the scope of the query. That is, how
many resources are returned from the request. It can be one of the
following.
-
:one
- Returns a single resource.
-
:first
- Returns the first resource found.
-
:last
- Returns the last resource found.
-
:all
- Returns every resource that matches the request.
Options¶ ↑
Examples¶ ↑
Person.find(1)
Person.find(:all)
Person.find(:all, :params => { :title => "CEO" })
Person.find(:first, :from => :managers)
Person.find(:last, :from => :managers)
Person.find(:all, :from => "/companies/1/people.json")
Person.find(:one, :from => :leader)
Person.find(:all, :from => :developers, :params => { :language => 'ruby' })
Person.find(:one, :from => "/companies/1/manager.json")
StreetAddress.find(1, :params => { :person_id => 1 })
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)
Person.find(:all)
Person.find(:first)
Person.find(:last)
def find(*arguments)
scope = arguments.slice!(0)
options = arguments.slice!(0) || {}
case scope
when :all then find_every(options)
when :first then find_every(options).first
when :last then find_every(options).last
when :one then find_one(options)
else find_single(scope, options)
end
end
first(*args)
click to toggle source
A convenience wrapper for find(:first, *args)
. You can pass in
all the same arguments to this method as you can to
find(:first)
.
def first(*args)
find(:first, *args)
end
known_attributes()
click to toggle source
Returns the list of known attributes for this resource, gathered from the
provided schema
Attributes that are known will cause your
resource to return 'true' when respond_to?
is called
on them. A known attribute will return nil if not set (rather than
MethodNotFound
); thus known attributes can be used with
validates_presence_of
without a getter-method.
def known_attributes
@known_attributes ||= []
end
last(*args)
click to toggle source
A convenience wrapper for find(:last, *args)
. You can pass in
all the same arguments to this method as you can to
find(:last)
.
def last(*args)
find(:last, *args)
end
logger()
click to toggle source
The logger for diagnosing and tracing Active Resource calls.
new(attributes = {}, persisted = false)
click to toggle source
Constructor method for new resources; the optional attributes
parameter takes a hash of attributes for the new resource.
Examples¶ ↑
my_course = Course.new
my_course.name = "Western Civilization"
my_course.lecturer = "Don Trotter"
my_course.save
my_other_course = Course.new(:name => "Philosophy: Reason and Being", :lecturer => "Ralph Cling")
my_other_course.save
def initialize(attributes = {}, persisted = false)
@attributes = {}.with_indifferent_access
@prefix_options = {}
@persisted = persisted
load(attributes, false, persisted)
end
new_element_path(prefix_options = {})
click to toggle source
Gets the new element path for REST resources.
Options¶ ↑
would yield a URL like /accounts/19/purchases/new.json
).
Examples¶ ↑
Post.new_element_path
class Comment < ActiveResource::Base
self.site = "https://37s.sunrise.com/posts/:post_id"
end
Comment.collection_path(:post_id => 5)
def new_element_path(prefix_options = {})
"#{prefix(prefix_options)}#{collection_name}/new#{format_extension}"
end
password()
click to toggle source
Gets the password for REST HTTP authentication.
def password
if defined?(@password)
@password
elsif superclass != Object && superclass.password
superclass.password.dup.freeze
end
end
password=(password)
click to toggle source
Sets the password for REST HTTP authentication.
def password=(password)
@connection = nil
@password = password
end
prefix(options={})
click to toggle source
Gets the prefix for a resource's nested URL (e.g.,
prefix/collectionname/1.json
) This method is regenerated at
runtime based on what the prefix is set to.
def prefix(options={})
default = site.path
default << '/' unless default[-1..-1] == '/'
self.prefix = default
prefix(options)
end
prefix=(value = '/')
click to toggle source
Sets the prefix for a resource's nested URL (e.g.,
prefix/collectionname/1.json
). Default value is
site.path
.
def prefix=(value = '/')
prefix_call = value.gsub(/:\w+/) { |key| "\#{URI.parser.escape options[#{key}].to_s}" }
@prefix_parameters = nil
silence_warnings do
instance_eval " def prefix_source() "#{value}" end
def prefix(options={}) "#{prefix_call}" end
", __FILE__, __LINE__ + 1
end
rescue Exception => e
logger.error "Couldn't set prefix: #{e}\n #{code}" if logger
raise
end
prefix_source()
click to toggle source
An attribute reader for the source string for the resource path prefix.
This method is regenerated at runtime based on what the prefix is set to.
def prefix_source
prefix
prefix_source
end
primary_key()
click to toggle source
def primary_key
if defined?(@primary_key)
@primary_key
elsif superclass != Object && superclass.primary_key
primary_key = superclass.primary_key
return primary_key if primary_key.is_a?(Symbol)
primary_key.dup.freeze
else
'id'
end
end
proxy()
click to toggle source
Gets the proxy variable if a proxy is required
def proxy
if defined?(@proxy)
@proxy
elsif superclass != Object && superclass.proxy
superclass.proxy.dup.freeze
end
end
proxy=(proxy)
click to toggle source
Sets the URI of the http proxy to the value in the proxy
argument.
def proxy=(proxy)
@connection = nil
@proxy = proxy.nil? ? nil : create_proxy_uri_from(proxy)
end
schema(&block)
click to toggle source
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 known_attributes
of the
current resource.
There is no need to specify a schema for your Active Resource. If you do
not, the known_attributes
will be guessed from the instance
attributes returned when an instance is fetched from the remote system.
example:
class Person < ActiveResource::Base
schema do
attribute 'name', :string
string 'eye_color', 'hair_color'
integer 'age'
float 'height', 'weight'
attribute 'created_at', 'string'
end
end
p = Person.new
p.respond_to? :name
p.respond_to? :age
p.name
p.age
j = Person.find_by_name('John')
<person><name>John</name><age>34</age><num_children>3</num_children></person>
j.respond_to? :name
j.respond_to? :age
j.name
j.age
j.num_children
p.num_children
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)
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
schema=(the_schema)
click to toggle source
Alternative, direct way to specify a schema
for this Resource.
schema
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
schema
)
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?
@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
site()
click to toggle source
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
if defined?(@site)
@site
elsif superclass != Object && superclass.site
superclass.site.dup.freeze
end
end
site=(site)
click to toggle source
Sets the URI of the REST resources to map for this class to the value in
the site
argument. The site variable is required for Active
Resource's mapping to work.
def site=(site)
@connection = nil
if site.nil?
@site = nil
else
@site = create_site_uri_from(site)
@user = URI.parser.unescape(@site.user) if @site.user
@password = URI.parser.unescape(@site.password) if @site.password
end
end
ssl_options()
click to toggle source
Returns the SSL options hash.
def ssl_options
if defined?(@ssl_options)
@ssl_options
elsif superclass != Object && superclass.ssl_options
superclass.ssl_options
end
end
ssl_options=(options)
click to toggle source
Options that will get applied to an SSL connection.
-
:key
- An OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.
-
:cert
- An OpenSSL::X509::Certificate object as client
certificate
-
:ca_file
- Path to a CA certification file in PEM format. The
file can contain several CA certificates.
-
:ca_path
- Path of a CA certification directory containing
certifications in PEM format.
-
:verify_mode
- Flags for server the certification verification
at beginning of SSL/TLS session. (OpenSSL::SSL::VERIFY_NONE or
OpenSSL::SSL::VERIFY_PEER is acceptable)
-
:verify_callback
- The verify callback for the server
certification verification.
-
:verify_depth
- The maximum depth for the certificate chain
verification.
-
:cert_store
- OpenSSL::X509::Store to verify peer certificate.
-
:ssl_timeout
-The SSL timeout in seconds.
def ssl_options=(options)
@connection = nil
@ssl_options = options
end
timeout()
click to toggle source
Gets the number of seconds after which requests to the REST API should time
out.
def timeout
if defined?(@timeout)
@timeout
elsif superclass != Object && superclass.timeout
superclass.timeout
end
end
timeout=(timeout)
click to toggle source
Sets the number of seconds after which requests to the REST API should time
out.
def timeout=(timeout)
@connection = nil
@timeout = timeout
end
user()
click to toggle source
Gets the user for REST HTTP authentication.
def user
if defined?(@user)
@user
elsif superclass != Object && superclass.user
superclass.user.dup.freeze
end
end
user=(user)
click to toggle source
Sets the user for REST HTTP authentication.
def user=(user)
@connection = nil
@user = user
end
where(clauses = {})
click to toggle source
def where(clauses = {})
raise ArgumentError, "expected a clauses Hash, got #{clauses.inspect}" unless clauses.is_a? Hash
find(:all, :params => clauses)
end
check_prefix_options(prefix_options)
click to toggle source
def check_prefix_options(prefix_options)
p_options = HashWithIndifferentAccess.new(prefix_options)
prefix_parameters.each do |p|
raise(MissingPrefixParam, "#{p} prefix_option is missing") if p_options[p].blank?
end
end
create_proxy_uri_from(proxy)
click to toggle source
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)
end
create_site_uri_from(site)
click to toggle source
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)
end
find_every(options)
click to toggle source
Find every resource
def find_every(options)
begin
case from = options[:from]
when Symbol
instantiate_collection(get(from, options[:params]), options[:params])
when String
path = "#{from}#{query_string(options[:params])}"
instantiate_collection(format.decode(connection.get(path, headers).body) || [], options[:params])
else
prefix_options, query_options = split_options(options[:params])
path = collection_path(prefix_options, query_options)
instantiate_collection( (format.decode(connection.get(path, headers).body) || []), query_options, prefix_options )
end
rescue ActiveResource::ResourceNotFound
nil
end
end
find_one(options)
click to toggle source
Find a single resource from a one-off URL
def find_one(options)
case from = options[:from]
when Symbol
instantiate_record(get(from, options[:params]))
when String
path = "#{from}#{query_string(options[:params])}"
instantiate_record(format.decode(connection.get(path, headers).body))
end
end
find_single(scope, options)
click to toggle source
Find a single resource from the default URL
def find_single(scope, options)
prefix_options, query_options = split_options(options[:params])
path = element_path(scope, prefix_options, query_options)
instantiate_record(format.decode(connection.get(path, headers).body), prefix_options)
end
instantiate_collection(collection, original_params = {}, prefix_options = {})
click to toggle source
def instantiate_collection(collection, original_params = {}, prefix_options = {})
collection_parser.new(collection).tap do |parser|
parser.resource_class = self
parser.original_params = original_params
end.collect! { |record| instantiate_record(record, prefix_options) }
end
instantiate_record(record, prefix_options = {})
click to toggle source
def instantiate_record(record, prefix_options = {})
new(record, true).tap do |resource|
resource.prefix_options = prefix_options
end
end
prefix_parameters()
click to toggle source
contains a set of the current prefix parameters.
def prefix_parameters
@prefix_parameters ||= prefix_source.scan(/:\w+/).map { |key| key[1..-1].to_sym }.to_set
end
query_string(options)
click to toggle source
Builds the query string for the request.
def query_string(options)
"?#{options.to_query}" unless options.nil? || options.empty?
end
split_options(options = {})
click to toggle source
split an option hash into two hashes, one containing the prefix options,
and the other containing the leftovers.
def split_options(options = {})
prefix_options, query_options = {}, {}
(options || {}).each do |key, value|
next if key.blank? || !key.respond_to?(:to_sym)
(prefix_parameters.include?(key.to_sym) ? prefix_options : query_options)[key.to_sym] = value
end
[ prefix_options, query_options ]
end
==(other)
click to toggle source
Test for equality. Resource are equal if and only if other
is
the same object or is an instance of the same class, is not
new?
, and has the same id
.
Examples¶ ↑
ryan = Person.create(:name => 'Ryan')
jamie = Person.create(:name => 'Jamie')
ryan == jamie
ryan_again = Person.new(:name => 'Ryan')
ryan == ryan_again
ryans_clone = Person.create(:name => 'Ryan')
ryan == ryans_clone
ryans_twin = Person.find(ryan.id)
ryan == ryans_twin
def ==(other)
other.equal?(self) || (other.instance_of?(self.class) && other.id == id && other.prefix_options == prefix_options)
end
clone()
click to toggle source
Returns a clone of the resource that hasn't been assigned an
id
yet and is treated as a new resource.
ryan = Person.find(1)
not_ryan = ryan.clone
not_ryan.new?
Any active resource member attributes will NOT be cloned, though all other
attributes are. This is to prevent the conflict between any
prefix_options
that refer to the original parent resource and
the newly cloned parent resource that does not exist.
ryan = Person.find(1)
ryan.address = StreetAddress.find(1, :person_id => ryan.id)
ryan.hash = {:not => "an ARes instance"}
not_ryan = ryan.clone
not_ryan.new?
not_ryan.address
not_ryan.hash
def clone
cloned = Hash[attributes.reject {|k,v| k == self.class.primary_key || v.is_a?(ActiveResource::Base)}.map { |k, v| [k, v.clone] }]
resource = self.class.new({})
resource.prefix_options = self.prefix_options
resource.send :instance_variable_set, '@attributes', cloned
resource
end
destroy()
click to toggle source
Deletes the resource from the remote service.
Examples¶ ↑
my_id = 3
my_person = Person.find(my_id)
my_person.destroy
Person.find(my_id)
new_person = Person.create(:name => 'James')
new_id = new_person.id
new_person.destroy
Person.find(new_id)
def destroy
run_callbacks :destroy do
connection.delete(element_path, self.class.headers)
end
end
dup()
click to toggle source
Duplicates the current resource without saving it.
Examples¶ ↑
my_invoice = Invoice.create(:customer => 'That Company')
next_invoice = my_invoice.dup
next_invoice.new?
next_invoice.save
next_invoice == my_invoice
my_invoice.customer
next_invoice.customer
def dup
self.class.new.tap do |resource|
resource.attributes = @attributes
resource.prefix_options = @prefix_options
end
end
encode(options={})
click to toggle source
Returns the serialized string representation of the resource in the
configured serialization format specified in ::format. The options applicable
depend on the configured encoding format.
def encode(options={})
send("to_#{self.class.format.extension}", options)
end
eql?(other)
click to toggle source
Tests for equality (delegates to ==).
def eql?(other)
self == other
end
exists?()
click to toggle source
Evaluates to true
if this resource is not new?
and is found on the remote service. Using this method, you can check for
resources that may have been deleted between the object's instantiation
and actions on it.
Examples¶ ↑
Person.create(:name => 'Theodore Roosevelt')
that_guy = Person.find(:first)
that_guy.exists?
that_lady = Person.new(:name => 'Paul Bean')
that_lady.exists?
guys_id = that_guy.id
Person.delete(guys_id)
that_guy.exists?
def exists?
!new? && self.class.exists?(to_param, :params => prefix_options)
end
hash()
click to toggle source
Delegates to id in order to allow two resources of the same type and id to
work with something like:
[(a = Person.find 1), (b = Person.find 2)] & [(c = Person.find 1), (d = Person.find 4)]
id()
click to toggle source
Gets the \id
attribute of the resource.
def id
attributes[self.class.primary_key]
end
id=(id)
click to toggle source
Sets the \id
attribute of the resource.
def id=(id)
attributes[self.class.primary_key] = id
end
known_attributes()
click to toggle source
This is a list of known attributes for this resource. Either gathered from
the provided schema
, 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)).uniq
end
load(attributes, remove_root = false, persisted = false)
click to toggle source
A method to manually load attributes from a hash. Recursively loads
collections of resources. This method is called in initialize
and create
when a hash of attributes is provided.
Examples¶ ↑
my_attrs = {:name => 'J&J Textiles', :industry => 'Cloth and textiles'}
my_attrs = {:name => 'Marty', :colors => ["red", "green", "blue"]}
the_supplier = Supplier.find(:first)
the_supplier.name
the_supplier.load(my_attrs)
the_supplier.name('J&J Textiles')
my_supplier = Supplier.new
my_supplier.load(my_attrs)
your_supplier = Supplier.new
your_supplier.load(my_attrs)
your_supplier.save
def load(attributes, remove_root = false, persisted = false)
raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
@prefix_options, attributes = split_options(attributes)
if attributes.keys.size == 1
remove_root = self.class.element_name == attributes.keys.first.to_s
end
attributes = Formats.remove_root(attributes) if remove_root
attributes.each do |key, value|
@attributes[key.to_s] =
case value
when Array
resource = nil
value.map do |attrs|
if attrs.is_a?(Hash)
resource ||= find_or_create_resource_for_collection(key)
resource.new(attrs, persisted)
else
attrs.duplicable? ? attrs.dup : attrs
end
end
when Hash
resource = find_or_create_resource_for(key)
resource.new(value, persisted)
else
value.duplicable? ? value.dup : value
end
end
self
end
new?()
click to toggle source
Returns true
if this object hasn't yet been saved,
otherwise, returns false
.
Examples¶ ↑
not_new = Computer.create(:brand => 'Apple', :make => 'MacBook', :vendor => 'MacMall')
not_new.new?
is_new = Computer.new(:brand => 'IBM', :make => 'Thinkpad', :vendor => 'IBM')
is_new.new?
is_new.save
is_new.new?
persisted?()
click to toggle source
Returns true
if this object has been saved, otherwise returns
false
.
Examples¶ ↑
persisted = Computer.create(:brand => 'Apple', :make => 'MacBook', :vendor => 'MacMall')
persisted.persisted?
not_persisted = Computer.new(:brand => 'IBM', :make => 'Thinkpad', :vendor => 'IBM')
not_persisted.persisted?
not_persisted.save
not_persisted.persisted?
def persisted?
@persisted
end
reload()
click to toggle source
A method to reload the attributes of this object from the remote web
service.
Examples¶ ↑
my_branch = Branch.find(:first)
my_branch.name
my_branch.name
my_branch.reload
my_branch.name
def reload
self.load(self.class.find(to_param, :params => @prefix_options).attributes, false, true)
end
respond_to?(method, include_priv = false)
click to toggle source
A method to determine if an object responds to a message (e.g., a method
call). In Active Resource, a Person object with a name
attribute can answer true
to
my_person.respond_to?(:name)
,
my_person.respond_to?(:name=)
, and
my_person.respond_to?(:name?)
.
Calls superclass method
def respond_to?(method, include_priv = false)
method_name = method.to_s
if attributes.nil?
super
elsif known_attributes.include?(method_name)
true
elsif method_name =~ /(?:=|\?)$/ && attributes.include?($`)
true
else
super
end
end
respond_to_without_attributes?(method, include_priv = false)
For checking respond_to?
without searching the attributes
(which is faster).
save()
click to toggle source
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 Json 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).
Examples¶ ↑
my_company = Company.new(:name => 'RoleModel Software', :owner => 'Ken Auer', :size => 2)
my_company.new?
my_company.save
my_company.new?
my_company.size = 10
my_company.save
def save
run_callbacks :save do
new? ? create : update
end
end
save!()
click to toggle source
Saves the resource.
If the resource is new, it is created via POST
, otherwise the
existing resource is updated via PUT
.
With save!
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 save!
. If
any of the before_*
callbacks return false
the
action is cancelled and save!
raises ActiveResource::ResourceInvalid.
def save!
save || raise(ResourceInvalid.new(self))
end
schema()
click to toggle source
If no schema has been defined for the class (see
ActiveResource::schema=
), the default automatic schema is
generated from the current instance's attributes
def schema
self.class.schema || self.attributes
end
to_json(options={})
click to toggle source
Calls superclass method
def to_json(options={})
super(include_root_in_json ? { :root => self.class.element_name }.merge(options) : options)
end
to_xml(options={})
click to toggle source
Calls superclass method
def to_xml(options={})
super({ :root => self.class.element_name }.merge(options))
end
update_attribute(name, value)
click to toggle source
Updates a single attribute and then saves the object.
Note: Unlike ActiveRecord::Base.update_attribute
, this method
is 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 false
will be returned.
def update_attribute(name, value)
self.send("#{name}=".to_sym, value)
self.save
end
update_attributes(attributes)
click to toggle source
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 false
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, false) && save
end