activeresource-five 5.0.0

data/lib/active_resource/log_subscriber.rb

@@ -0,0 +1,15 @@
+module ActiveResource
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    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
+
+ActiveResource::LogSubscriber.attach_to :active_resource

data/lib/active_resource/railtie.rb

@@ -0,0 +1,15 @@
+require "active_resource"
+require "rails"
+
+module ActiveResource
+  class Railtie < Rails::Railtie
+    config.active_resource = ActiveSupport::OrderedOptions.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/reflection.rb

@@ -0,0 +1,77 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/deprecation'
+
+module ActiveResource
+  # = Active Resource reflection
+  #
+  # Associations in ActiveResource would be used to resolve nested attributes
+  # in a response with correct classes.
+  # Now they could be specified over Associations with the options :class_name
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    module ClassMethods
+      def create_reflection(macro, name, options)
+        reflection = AssociationReflection.new(macro, name, options)
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+    end
+
+
+    class AssociationReflection
+
+      def initialize(macro, name, options)
+        @macro, @name, @options = macro, name, options
+      end
+
+      # Returns the name of the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      # Returns the class for the macro.
+      #
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= derive_class_name
+      end
+
+      # Returns the foreign_key for the macro.
+      def foreign_key
+        @foreign_key ||= self.options[:foreign_key] || "#{self.name.to_s.downcase}_id"
+      end
+
+      private
+      def derive_class_name
+        return (options[:class_name] ? options[:class_name].to_s.camelize : name.to_s.classify)
+      end
+
+      def derive_foreign_key
+        return options[:foreign_key] ? options[:foreign_key].to_s : "#{name.to_s.downcase}_id"
+      end
+    end
+  end
+end

data/lib/active_resource/schema.rb

@@ -0,0 +1,57 @@
+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 text integer float decimal datetime timestamp time date binary boolean )
+
+    # 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 schema of the actual
+    #  resource.
+    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.
+    KNOWN_ATTRIBUTE_TYPES.each do |attr_type|
+      # def string(*args)
+      #   options = args.extract_options!
+      #   attr_names = args
+      #
+      #   attr_names.each { |name| attribute(name, 'string', options) }
+      # end
+      class_eval <<-EOV, __FILE__, __LINE__ + 1
+        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/singleton.rb

@@ -0,0 +1,114 @@
+module ActiveResource
+  module Singleton
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_writer :singleton_name
+
+      def singleton_name
+        @singleton_name ||= model_name.element
+      end
+
+      # Gets the singleton path for the object.  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., <tt>:account_id => 19</tt>
+      # would yield a URL like <tt>/accounts/19/purchases.json</tt>).
+      #
+      # * +query_options+ - A \hash to add items to the query string for the request.
+      #
+      # ==== Examples
+      #   Weather.singleton_path
+      #   # => /weather.json
+      #
+      #   class Inventory < ActiveResource::Base
+      #     self.site =   "https://37s.sunrise.com"
+      #     self.prefix = "/products/:product_id/"
+      #   end
+      #
+      #   Inventory.singleton_path(:product_id => 5)
+      #   # => /products/5/inventory.json
+      #
+      #   Inventory.singleton_path({:product_id => 5}, {:sold => true})
+      #   # => /products/5/inventory.json?sold=true
+      #
+      def singleton_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)}#{singleton_name}#{format_extension}#{query_string(query_options)}"
+      end
+
+      # Core method for finding singleton resources.
+      #
+      # ==== Arguments
+      # Takes a single argument of options
+      #
+      # ==== Options
+      # * <tt>:params</tt> - Sets the query and \prefix (nested URL) parameters.
+      #
+      # ==== Examples
+      #   Weather.find
+      #   # => GET /weather.json
+      #
+      #   Weather.find(:params => {:degrees => 'fahrenheit'})
+      #   # => GET /weather.json?degrees=fahrenheit
+      #
+      # == Failure or missing data
+      # A failure to find the requested object raises a ResourceNotFound exception.
+      #
+      #   Inventory.find
+      #   # => raises ResourceNotFound
+      def find(options={})
+        find_singleton(options)
+      end
+
+      private
+      # Find singleton resource
+      def find_singleton(options)
+        prefix_options, query_options = split_options(options[:params])
+
+        path = singleton_path(prefix_options, query_options)
+        resp = self.format.decode(self.connection.get(path, self.headers).body)
+        instantiate_record(resp, prefix_options)
+      end
+
+    end
+    # Deletes the resource from the remote service.
+    #
+    # ==== Examples
+    #   weather = Weather.find
+    #   weather.destroy
+    #   Weather.find # 404 (Resource Not Found)
+    def destroy
+      connection.delete(singleton_path, self.class.headers)
+    end
+
+
+    protected
+
+    # Update the resource on the remote service
+    def update
+      connection.put(singleton_path(prefix_options), encode, self.class.headers).tap do |response|
+        load_attributes_from_response(response)
+      end
+    end
+
+    # Create (i.e. \save to the remote service) the \new resource.
+    def create
+      connection.post(singleton_path, encode, self.class.headers).tap do |response|
+        self.id = id_from_response(response)
+        load_attributes_from_response(response)
+      end
+    end
+
+    private
+
+    def singleton_path(options = nil)
+      self.class.singleton_path(options || prefix_options)
+    end
+
+  end
+
+end

data/lib/active_resource/threadsafe_attributes.rb

@@ -0,0 +1,65 @@
+require 'active_support/core_ext/object/duplicable'
+
+module ThreadsafeAttributes
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def threadsafe_attribute(*attrs)
+      main_thread = Thread.main # remember this, because it could change after forking
+
+      attrs.each do |attr|
+        define_method attr do
+          get_threadsafe_attribute(attr, main_thread)
+        end
+
+        define_method "#{attr}=" do |value|
+          set_threadsafe_attribute(attr, value, main_thread)
+        end
+
+        define_method "#{attr}_defined?" do
+          threadsafe_attribute_defined?(attr, main_thread)
+        end
+      end
+    end
+  end
+
+  private
+
+  def get_threadsafe_attribute(name, main_thread)
+    if threadsafe_attribute_defined_by_thread?(name, Thread.current)
+      get_threadsafe_attribute_by_thread(name, Thread.current)
+    elsif threadsafe_attribute_defined_by_thread?(name, main_thread)
+      value = get_threadsafe_attribute_by_thread(name, main_thread)
+      value = value.dup if value.duplicable?
+      set_threadsafe_attribute_by_thread(name, value, Thread.current)
+      value
+    end
+  end
+
+  def set_threadsafe_attribute(name, value, main_thread)
+    set_threadsafe_attribute_by_thread(name, value, Thread.current)
+    unless threadsafe_attribute_defined_by_thread?(name, main_thread)
+      set_threadsafe_attribute_by_thread(name, value, main_thread)
+    end
+  end
+
+  def threadsafe_attribute_defined?(name, main_thread)
+    threadsafe_attribute_defined_by_thread?(name, Thread.current) || ((Thread.current != main_thread) && threadsafe_attribute_defined_by_thread?(name, main_thread))
+  end
+
+  def get_threadsafe_attribute_by_thread(name, thread)
+    thread["active.resource.#{name}.#{self.object_id}"]
+  end
+
+  def set_threadsafe_attribute_by_thread(name, value, thread)
+    thread["active.resource.#{name}.#{self.object_id}.defined"] = true
+    thread["active.resource.#{name}.#{self.object_id}"] = value
+  end
+
+  def threadsafe_attribute_defined_by_thread?(name, thread)
+    thread["active.resource.#{name}.#{self.object_id}.defined"]
+  end
+
+end

data/lib/active_resource/validations.rb

@@ -0,0 +1,174 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
+
+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 < ActiveModel::Errors
+    # Grabs errors from an array of messages (like ActiveRecord::Validations).
+    # 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 = Hash[@base.known_attributes.map { |attr_name| [attr_name.humanize, attr_name] }]
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.sort_by { |a| -a.length }.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        self[:base] << message if attr_message.nil?
+      end
+    end
+
+    # Grabs errors from a hash of attribute => array of errors elements
+    # The second parameter directs the errors cache to be cleared (default)
+    # or not (by passing true)
+    #
+    # Unrecognized attribute names will be humanized and added to the record's
+    # base errors.
+    def from_hash(messages, save_cache = false)
+      clear unless save_cache
+
+      messages.each do |(key,errors)|
+        errors.each do |error|
+          if @base.known_attributes.include?(key)
+            add key, error
+          elsif key == 'base'
+            self[:base] << error
+          else
+            # reporting an error on an attribute not in attributes
+            # format and add them to base
+            self[:base] << "#{key.humanize} #{error}"
+          end
+        end
+      end
+    end
+
+    # Grabs errors from a json response.
+    def from_json(json, save_cache = false)
+      decoded = ActiveSupport::JSON.decode(json) || {} rescue {}
+      if decoded.kind_of?(Hash) && (decoded.has_key?('errors') || decoded.empty?)
+        errors = decoded['errors'] || {}
+        if errors.kind_of?(Array)
+          # 3.2.1-style with array of strings
+          ActiveSupport::Deprecation.warn('Returning errors as an array of strings is deprecated.')
+          from_array errors, save_cache
+        else
+          # 3.2.2+ style
+          from_hash errors, save_cache
+        end
+      else
+        # <3.2-style respond_with - lacks 'errors' key
+        ActiveSupport::Deprecation.warn('Returning errors as a hash without a root "errors" key is deprecated.')
+        from_hash decoded, save_cache
+      end
+    end
+
+    # 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, save_cache
+    end
+  end
+
+  # 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 ActiveModel::Errors.
+  #
+  # ==== Example
+  #
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a
+  # <tt>validates_presence_of :first_name, :last_name</tt> 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)
+  #
+  module Validations
+    extend  ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    included do
+      alias_method :save_without_validation, :save
+      alias_method :save, :save_with_validation
+    end
+
+    # Validate a resource and save (POST) it to the remote web service.
+    # If any local validations fail - the save (POST) will not be attempted.
+    def save_with_validation(options={})
+      perform_validation = options[:validate] != false
+
+      # 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(remote_errors.response.body, save_cache)
+      when ActiveResource::Formats[:json]
+        errors.from_json(remote_errors.response.body, save_cache)
+      end
+    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])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    #
+    def valid?
+      run_callbacks :validate do
+        super
+        load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?
+        errors.empty?
+      end
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end