activeresource 2.3.18 → 3.0.0.beta

data/lib/active_resource/observing.rb

@@ -0,0 +1,21 @@
+module ActiveResource
+  module Observing
+    extend ActiveSupport::Concern
+    include ActiveModel::Observing
+
+    included do
+      %w( create save update destroy ).each do |method|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method}_with_notifications(*args, &block)
+            notify_observers(:before_#{method})
+            if result = #{method}_without_notifications(*args, &block)
+              notify_observers(:after_#{method})
+            end
+            result
+          end
+        EOS
+        alias_method_chain(method, :notifications)
+      end
+    end
+  end
+end

data/lib/active_resource/railtie.rb

@@ -0,0 +1,17 @@
+require "active_resource"
+require "rails"
+
+module ActiveResource
+  class Railtie < Rails::Railtie
+    railtie_name :active_resource
+
+    require "active_resource/railties/subscriber"
+    subscriber ActiveResource::Railties::Subscriber.new
+
+    initializer "active_resource.set_configs" do |app|
+      app.config.active_resource.each do |k,v|
+        ActiveResource::Base.send "#{k}=", v
+      end
+    end
+  end
+end

data/lib/active_resource/railties/subscriber.rb

@@ -0,0 +1,15 @@
+module ActiveResource
+  module Railties
+    class Subscriber < Rails::Subscriber
+      def request(event)
+        result = event.payload[:result]
+        info "#{event.payload[:method].to_s.upcase} #{event.payload[:request_uri]}"
+        info "--> %d %s %d (%.1fms)" % [result.code, result.message, result.body.to_s.length, event.duration]
+      end
+
+      def logger
+        ActiveResource::Base.logger
+      end
+    end
+  end
+end

data/lib/active_resource/schema.rb

@@ -0,0 +1,55 @@
+require 'active_resource/exceptions'
+
+module ActiveResource # :nodoc:
+  class Schema # :nodoc:
+    # attributes can be known to be one of these types. They are easy to
+    # cast to/from.
+    KNOWN_ATTRIBUTE_TYPES = %w( string integer float )
+
+    # An array of attribute definitions, representing the attributes that
+    # have been defined.
+    attr_accessor :attrs
+
+    # The internals of an Active Resource Schema are very simple -
+    # unlike an Active Record TableDefinition (on which it is based).
+    # It provides a set of convenience methods for people to define their
+    # schema using the syntax:
+    #  schema do
+    #    string :foo
+    #    integer :bar
+    #  end
+    #
+    #  The schema stores the name and type of each attribute. That is then
+    #  read out by the schema method to populate the actual
+    #  Resource's schema
+    def initialize
+      @attrs = {}
+    end
+
+    def attribute(name, type, options = {})
+      raise ArgumentError, "Unknown Attribute type: #{type.inspect} for key: #{name.inspect}" unless type.nil? || Schema::KNOWN_ATTRIBUTE_TYPES.include?(type.to_s)
+
+      the_type = type.to_s
+      # TODO: add defaults
+      #the_attr = [type.to_s]
+      #the_attr << options[:default] if options.has_key? :default
+      @attrs[name.to_s] = the_type
+      self
+    end
+
+    # The following are the attribute types supported by Active Resource
+    # migrations.
+    # TODO:  We should eventually support all of these:
+    # %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |attr_type|
+    KNOWN_ATTRIBUTE_TYPES.each do |attr_type|
+      class_eval <<-EOV
+        def #{attr_type.to_s}(*args)
+          options = args.extract_options!
+          attr_names = args
+
+          attr_names.each { |name| attribute(name, '#{attr_type}', options) }
+        end
+      EOV
+    end
+  end
+end

data/lib/active_resource/validations.rb

@@ -1,207 +1,17 @@
+require 'active_support/core_ext/array/wrap'
+
 module ActiveResource
   class ResourceInvalid < ClientError  #:nodoc:
   end
 
   # Active Resource validation is reported to and from this object, which is used by Base#save
   # to determine whether the object in a valid state to be saved. See usage example in Validations.  
-  class Errors
-    include Enumerable
-    attr_reader :errors
-
-    delegate :empty?, :to => :errors
-    
-    def initialize(base) # :nodoc:
-      @base, @errors = base, {}
-    end
-
-    # Add an error to the base Active Resource object rather than an attribute.
-    #
-    # ==== Examples
-    #   my_folder = Folder.find(1)
-    #   my_folder.errors.add_to_base("You can't edit an existing folder")
-    #   my_folder.errors.on_base
-    #   # => "You can't edit an existing folder"
-    #
-    #   my_folder.errors.add_to_base("This folder has been tagged as frozen")
-    #   my_folder.valid?
-    #   # => false
-    #   my_folder.errors.on_base
-    #   # => ["You can't edit an existing folder", "This folder has been tagged as frozen"]
-    #
-    def add_to_base(msg)
-      add(:base, msg)
-    end
-
-    # Adds an error to an Active Resource object's attribute (named for the +attribute+ parameter)
-    # with the error message in +msg+.
-    #
-    # ==== Examples
-    #   my_resource = Node.find(1)
-    #   my_resource.errors.add('name', 'can not be "base"') if my_resource.name == 'base'
-    #   my_resource.errors.on('name')
-    #   # => 'can not be "base"!'
-    #
-    #   my_resource.errors.add('desc', 'can not be blank') if my_resource.desc == ''
-    #   my_resource.valid?
-    #   # => false
-    #   my_resource.errors.on('desc')
-    #   # => 'can not be blank!'
-    #
-    def add(attribute, msg)
-      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
-      @errors[attribute.to_s] << msg
-    end
-
-    # Returns true if the specified +attribute+ has errors associated with it.
-    #
-    # ==== Examples
-    #   my_resource = Disk.find(1)
-    #   my_resource.errors.add('location', 'must be Main') unless my_resource.location == 'Main'
-    #   my_resource.errors.on('location')
-    #   # => 'must be Main!'
-    #
-    #   my_resource.errors.invalid?('location')
-    #   # => true
-    #   my_resource.errors.invalid?('name')
-    #   # => false
-    def invalid?(attribute)
-      !@errors[attribute.to_s].nil?
-    end
-
-    # A method to return the errors associated with +attribute+, which returns nil, if no errors are 
-    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
-    # or an array of error messages if more than one error is associated with the specified +attribute+.
-    #
-    # ==== Examples
-    #   my_person = Person.new(params[:person])
-    #   my_person.errors.on('login')
-    #   # => nil
-    #
-    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
-    #   my_person.errors.on('login')
-    #   # => 'can not be empty'
-    #
-    #   my_person.errors.add('login', 'can not be longer than 10 characters') if my_person.login.length > 10
-    #   my_person.errors.on('login')
-    #   # => ['can not be empty', 'can not be longer than 10 characters']
-    def on(attribute)
-      errors = @errors[attribute.to_s]
-      return nil if errors.nil?
-      errors.size == 1 ? errors.first : errors
-    end
-    
-    alias :[] :on
-
-    # A method to return errors assigned to +base+ object through add_to_base, which returns nil, if no errors are 
-    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
-    # or an array of error messages if more than one error is associated with the specified +attribute+.
-    #
-    # ==== Examples
-    #   my_account = Account.find(1)
-    #   my_account.errors.on_base
-    #   # => nil
-    #
-    #   my_account.errors.add_to_base("This account is frozen")
-    #   my_account.errors.on_base
-    #   # => "This account is frozen"
-    #
-    #   my_account.errors.add_to_base("This account has been closed")
-    #   my_account.errors.on_base
-    #   # => ["This account is frozen", "This account has been closed"]
-    #
-    def on_base
-      on(:base)
-    end
-
-    # Yields each attribute and associated message per error added.
-    #
-    # ==== Examples
-    #   my_person = Person.new(params[:person])
-    #
-    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
-    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
-    #   messages = ''
-    #   my_person.errors.each {|attr, msg| messages += attr.humanize + " " + msg + "<br />"}
-    #   messages
-    #   # => "Login can not be empty<br />Password can not be empty<br />"
-    #
-    def each
-      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
-    end
-
-    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
-    # through iteration as "First name can't be empty".
-    #
-    # ==== Examples
-    #   my_person = Person.new(params[:person])
-    #
-    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
-    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
-    #   messages = ''
-    #   my_person.errors.each_full {|msg| messages += msg + "<br/>"}
-    #   messages
-    #   # => "Login can not be empty<br />Password can not be empty<br />"
-    #
-    def each_full
-      full_messages.each { |msg| yield msg }
-    end
-
-    # Returns all the full error messages in an array.
-    #
-    # ==== Examples
-    #   my_person = Person.new(params[:person])
-    #
-    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
-    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
-    #   messages = ''
-    #   my_person.errors.full_messages.each {|msg| messages += msg + "<br/>"}
-    #   messages
-    #   # => "Login can not be empty<br />Password can not be empty<br />"
-    #
-    def full_messages
-      full_messages = []
-
-      @errors.each_key do |attr|
-        @errors[attr].each do |msg|
-          next if msg.nil?
-
-          if attr == "base"
-            full_messages << msg
-          else
-            full_messages << [attr.humanize, msg].join(' ')
-          end
-        end
-      end
-      full_messages
-    end
-
-    def clear
-      @errors = {}
-    end
-
-    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
-    # with this as well.
-    #
-    # ==== Examples
-    #   my_person = Person.new(params[:person])
-    #   my_person.errors.size
-    #   # => 0
-    #
-    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
-    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
-    #   my_person.error.size
-    #   # => 2
-    #
-    def size
-      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
-    end
-
-    alias_method :count, :size
-    alias_method :length, :size
-    
+  class Errors < ActiveModel::Errors
     # Grabs errors from an array of messages (like ActiveRecord::Validations)
-    def from_array(messages)
-      clear
+    # The second parameter directs the errors cache to be cleared (default)
+    # or not (by passing true)
+    def from_array(messages, save_cache = false)
+      clear unless save_cache
       humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
       messages.each do |message|
         attr_message = humanized_attributes.keys.detect do |attr_name|
@@ -210,20 +20,20 @@ module ActiveResource
           end
         end
         
-        add_to_base message if attr_message.nil?
+        self[:base] << message if attr_message.nil?
       end
     end
 
-    # Grabs errors from the json response.
-    def from_json(json)
+    # Grabs errors from a json response.
+    def from_json(json, save_cache = false)
       array = ActiveSupport::JSON.decode(json)['errors'] rescue []
-      from_array array
+      from_array array, save_cache
     end
 
-    # Grabs errors from the XML response.
-    def from_xml(xml)
+    # Grabs errors from an XML response.
+    def from_xml(xml, save_cache = false)
       array = Array.wrap(Hash.from_xml(xml)['errors']['error']) rescue []
-      from_array array
+      from_array array, save_cache
     end
   end
   
@@ -243,32 +53,70 @@ module ActiveResource
   #   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.errors[: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:
-      base.class_eval do
-        alias_method_chain :save, :validation
-      end
+    extend  ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    included do
+      alias_method_chain :save, :validation
     end
 
     # Validate a resource and save (POST) it to the remote web service.
-    def save_with_validation
-      save_without_validation
-      true
+    # If any local validations fail - the save (POST) will not be attempted.
+    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
+
+
+    # Loads the set of remote errors into the object's Errors based on the
+    # content-type of the error-block received
+    def load_remote_errors(remote_errors, save_cache = false ) #:nodoc:
       case self.class.format
       when ActiveResource::Formats[:xml]
-        errors.from_xml(error.response.body)
+        errors.from_xml(remote_errors.response.body, save_cache)
       when ActiveResource::Formats[:json]
-        errors.from_json(error.response.body)
+        errors.from_json(remote_errors.response.body, save_cache)
       end
-      false
     end
 
     # 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])
@@ -278,7 +126,10 @@ module ActiveResource
     #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
     #   my_person.valid?
     #   # => false
+    #
     def valid?
+      super
+      load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?
       errors.empty?
     end
 

data/lib/active_resource/version.rb

@@ -1,8 +1,8 @@
 module ActiveResource
   module VERSION #:nodoc:
-    MAJOR = 2
-    MINOR = 3
-    TINY  = 18
+    MAJOR = 3
+    MINOR = 0
+    TINY  = "0.beta"
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end