activeresource 3.2.22.5 → 4.0.0.beta1

data/lib/active_resource/callbacks.rb

@@ -0,0 +1,20 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveResource
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation, :before_save, :around_save, :after_save,
+      :before_create, :around_create, :after_create, :before_update, :around_update,
+      :after_update, :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+  end
+end

data/lib/active_resource/collection.rb

@@ -0,0 +1,85 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/inflector'
+
+module ActiveResource # :nodoc:
+  class Collection # :nodoc:
+    include Enumerable
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :size, :last, :first, :[], :to => :to_a
+
+    # The array of actual elements returned by index actions
+    attr_accessor :elements, :resource_class, :original_params
+    
+    # ActiveResource::Collection is a wrapper to handle parsing index responses that
+    # do not directly map to Rails conventions.
+    #
+    # You can define a custom class that inherets from ActiveResource::Collection
+    # in order to to set the elements instance. 
+    #
+    # GET /posts.json delivers following response body:
+    #   {
+    #     posts: [
+    #       {
+    #         title: "ActiveResource now has associations",
+    #         body: "Lorem Ipsum"
+    #       }
+    #       {...}
+    #     ]
+    #     next_page: "/posts.json?page=2"
+    #   }
+    # 
+    # A Post class can be setup to handle it with:
+    #
+    #   class Post < ActiveResource::Base
+    #     self.site = "http://example.com"
+    #     self.collection_parser = PostParser
+    #   end
+    #
+    # And the collection parser:
+    #
+    #   class PostCollection < ActiveResource::Collection
+    #     attr_accessor :next_page
+    #     def initialize(parsed = {})
+    #       @elements = parsed['posts']
+    #       @next_page = parsed['next_page']
+    #     end
+    #   end
+    #
+    # The result from a find method that returns multiple entries will now be a 
+    # PostParser instance.  ActiveResource::Collection includes Enumerable and
+    # instances can be iterated over just like an array.
+    #    @posts = Post.find(:all) # => PostCollection:xxx
+    #    @posts.next_page         # => "/posts.json?page=2"
+    #    @posts.map(&:id)         # =>[1, 3, 5 ...]
+    #
+    # The initialize method will receive the ActiveResource::Formats parsed result
+    # and should set @elements.
+    def initialize(elements = [])
+      @elements = elements
+    end
+    
+    def to_a
+      elements
+    end
+    
+    def collect!
+      return elements unless block_given?
+      set = []
+      each { |o| set << yield(o) }
+      @elements = set
+      self
+    end
+    alias map! collect!
+
+    def first_or_create(attributes = {})
+      first || resource_class.create(original_params.update(attributes))
+    rescue NoMethodError
+      raise "Cannot create resource from resource type: #{resource_class.inspect}"
+    end
+
+    def first_or_initialize(attributes = {})
+      first || resource_class.new(original_params.update(attributes))
+    rescue NoMethodError
+      raise "Cannot build resource from resource type: #{resource_class.inspect}"
+    end
+  end
+end

data/lib/active_resource/connection.rb

@@ -15,6 +15,7 @@ module ActiveResource
     HTTP_FORMAT_HEADER_NAMES = {  :get => 'Accept',
       :put => 'Content-Type',
       :post => 'Content-Type',
+      :patch => 'Content-Type',
       :delete => 'Accept',
       :head => 'Accept'
     }
@@ -39,14 +40,15 @@ module ActiveResource
 
     # Set URI for remote service.
     def site=(site)
-      @site = site.is_a?(URI) ? site : URI.parser.parse(site)
+      @site = site.is_a?(URI) ? site : URI.parse(site)
+      @ssl_options ||= {} if @site.is_a?(URI::HTTPS)
       @user = URI.parser.unescape(@site.user) if @site.user
       @password = URI.parser.unescape(@site.password) if @site.password
     end
 
     # Set the proxy for remote service.
     def proxy=(proxy)
-      @proxy = proxy.is_a?(URI) ? proxy : URI.parser.parse(proxy)
+      @proxy = proxy.is_a?(URI) ? proxy : URI.parse(proxy)
     end
 
     # Sets the user for remote service.
@@ -70,8 +72,8 @@ module ActiveResource
     end
 
     # Hash of options applied to Net::HTTP instance when +site+ protocol is 'https'.
-    def ssl_options=(opts={})
-      @ssl_options = opts
+    def ssl_options=(options)
+      @ssl_options = options
     end
 
     # Executes a GET request.
@@ -86,6 +88,12 @@ module ActiveResource
       with_auth { request(:delete, path, build_request_headers(headers, :delete, self.site.merge(path))) }
     end
 
+    # Executes a PATCH request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def patch(path, body = '', headers = {})
+      with_auth { request(:patch, path, body.to_s, build_request_headers(headers, :patch, self.site.merge(path))) }
+    end
+
     # Executes a PUT request (see HTTP protocol documentation if unfamiliar).
     # Used to update resources.
     def put(path, body = '', headers = {})
@@ -166,38 +174,28 @@ module ActiveResource
       end
 
       def configure_http(http)
-        http = apply_ssl_options(http)
-
-        # Net::HTTP timeouts default to 60 seconds.
-        if @timeout
-          http.open_timeout = @timeout
-          http.read_timeout = @timeout
+        apply_ssl_options(http).tap do |https|
+          # Net::HTTP timeouts default to 60 seconds.
+          if defined? @timeout
+            https.open_timeout = @timeout
+            https.read_timeout = @timeout
+          end
         end
-
-        http
       end
 
       def apply_ssl_options(http)
-        return http unless @site.is_a?(URI::HTTPS)
+        http.tap do |https|
+          # Skip config if site is already a https:// URI.
+          if defined? @ssl_options
+            http.use_ssl = true
 
-        http.use_ssl     = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        return http unless defined?(@ssl_options)
+            # Default to no cert verification (WTF? FIXME)
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
 
-        http.ca_path     = @ssl_options[:ca_path] if @ssl_options[:ca_path]
-        http.ca_file     = @ssl_options[:ca_file] if @ssl_options[:ca_file]
-
-        http.cert        = @ssl_options[:cert] if @ssl_options[:cert]
-        http.key         = @ssl_options[:key]  if @ssl_options[:key]
-
-        http.cert_store  = @ssl_options[:cert_store]  if @ssl_options[:cert_store]
-        http.ssl_timeout = @ssl_options[:ssl_timeout] if @ssl_options[:ssl_timeout]
-
-        http.verify_mode     = @ssl_options[:verify_mode]     if @ssl_options[:verify_mode]
-        http.verify_callback = @ssl_options[:verify_callback] if @ssl_options[:verify_callback]
-        http.verify_depth    = @ssl_options[:verify_depth]    if @ssl_options[:verify_depth]
-
-        http
+            # All the SSL options have corresponding http settings.
+            @ssl_options.each { |key, value| http.send "#{key}=", value }
+          end
+        end
       end
 
       def default_header

data/lib/active_resource/custom_methods.rb

@@ -2,25 +2,25 @@ require 'active_support/core_ext/object/blank'
 
 module ActiveResource
   # 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,
+  # 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:
+  # 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
+  #    POST      /people/new/register.json # PeopleController.register
+  #    PATCH/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"
+  #     self.site = "https://37s.sunrise.com"
   #   end
   #
   #   Person.new(:name => 'Ryan').post(:register)  # POST /people/new/register.json
@@ -63,6 +63,10 @@ module ActiveResource
           connection.post(custom_method_collection_url(custom_method_name, options), body, headers)
         end
 
+        def patch(custom_method_name, options = {}, body = '')
+          connection.patch(custom_method_collection_url(custom_method_name, options), body, headers)
+        end
+
         def put(custom_method_name, options = {}, body = '')
           connection.put(custom_method_collection_url(custom_method_name, options), body, headers)
         end
@@ -81,7 +85,7 @@ module ActiveResource
     module ClassMethods
       def custom_method_collection_url(method_name, options = {})
         prefix_options, query_options = split_options(options)
-        "#{prefix(prefix_options)}#{collection_name}/#{method_name}.#{format.extension}#{query_string(query_options)}"
+        "#{prefix(prefix_options)}#{collection_name}/#{method_name}#{format_extension}#{query_string(query_options)}"
       end
     end
 
@@ -98,6 +102,10 @@ module ActiveResource
       end
     end
 
+    def patch(method_name, options = {}, body = '')
+      connection.patch(custom_method_element_url(method_name, options), body, self.class.headers)
+    end
+
     def put(method_name, options = {}, body = '')
       connection.put(custom_method_element_url(method_name, options), body, self.class.headers)
     end
@@ -109,11 +117,11 @@ module ActiveResource
 
     private
       def custom_method_element_url(method_name, options = {})
-        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}.#{self.class.format.extension}#{self.class.__send__(:query_string, options)}"
+        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}#{self.class.format_extension}#{self.class.__send__(:query_string, options)}"
       end
 
       def custom_method_new_element_url(method_name, options = {})
-        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/new/#{method_name}.#{self.class.format.extension}#{self.class.__send__(:query_string, options)}"
+        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/new/#{method_name}#{self.class.format_extension}#{self.class.__send__(:query_string, options)}"
       end
   end
 end

data/lib/active_resource/http_mock.rb

@@ -4,7 +4,7 @@ require 'active_support/core_ext/object/inclusion'
 module ActiveResource
   class InvalidRequestError < StandardError; end #:nodoc:
 
-  # One thing that has always been a pain with remote web services is testing.  The HttpMock
+  # One thing that has always been a pain with remote web services is testing. The HttpMock
   # class makes it easy to test your Active Resource models by creating a set of mock responses to specific
   # requests.
   #
@@ -15,17 +15,17 @@ module ActiveResource
   #
   #   mock.http_method(path, request_headers = {}, body = nil, status = 200, response_headers = {})
   #
-  # * <tt>http_method</tt> - The HTTP method to listen for.  This can be +get+, +post+, +put+, +delete+ or
+  # * <tt>http_method</tt> - The HTTP method to listen for. This can be +get+, +post+, +patch+, +put+, +delete+ or
   #   +head+.
   # * <tt>path</tt> - A string, starting with a "/", defining the URI that is expected to be
   #   called.
-  # * <tt>request_headers</tt> - Headers that are expected along with the request.  This argument uses a
-  #   hash format, such as <tt>{ "Content-Type" => "application/json" }</tt>.  This mock will only trigger
+  # * <tt>request_headers</tt> - Headers that are expected along with the request. This argument uses a
+  #   hash format, such as <tt>{ "Content-Type" => "application/json" }</tt>. This mock will only trigger
   #   if your tests sends a request with identical headers.
-  # * <tt>body</tt> - The data to be returned.  This should be a string of Active Resource parseable content,
+  # * <tt>body</tt> - The data to be returned. This should be a string of Active Resource parseable content,
   #   such as Json.
   # * <tt>status</tt> - The HTTP response code, as an integer, to return with the response.
-  # * <tt>response_headers</tt> - Headers to be returned with the response.  Uses the same hash format as
+  # * <tt>response_headers</tt> - Headers to be returned with the response. Uses the same hash format as
   #   <tt>request_headers</tt> listed above.
   #
   # In order for a mock to deliver its content, the incoming request must match by the <tt>http_method</tt>,
@@ -55,7 +55,7 @@ module ActiveResource
         @responses = responses
       end
 
-      [ :post, :put, :get, :delete, :head ].each do |method|
+      [ :post, :patch, :put, :get, :delete, :head ].each do |method|
         # def post(path, request_headers = {}, body = nil, status = 200, response_headers = {})
         #   @responses[Request.new(:post, path, nil, request_headers)] = Response.new(body || "", status, response_headers)
         # end
@@ -133,7 +133,7 @@ module ActiveResource
       #
       # === Example
       #
-      # Request.new(:#{method}, path, nil, request_headers)
+      # Request.new(method, path, nil, request_headers)
       #
       #   @matz  = { :person => { :id => 1, :name => "Matz" } }.to_json
       #
@@ -217,7 +217,7 @@ module ActiveResource
     end
 
     # body?       methods
-    { true  => %w(post put),
+    { true  => %w(post patch put),
       false => %w(get delete head) }.each do |has_body, methods|
       methods.each do |method|
         # def post(path, body, headers)
@@ -292,11 +292,8 @@ module ActiveResource
         @body = nil
       end
 
-      if @body.nil?
-        self['Content-Length'] = "0"
-      else
-        self['Content-Length'] = body.size.to_s
-      end
+      self['Content-Length'] = @body.nil? ? "0" : body.size.to_s
+
     end
 
     # Returns true if code is 2xx,

data/lib/active_resource/observing.rb

@@ -1,3 +1,5 @@
+require 'rails/observers/active_model/observing'
+
 module ActiveResource
   module Observing
     extend ActiveSupport::Concern

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 : 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

@@ -1,5 +1,3 @@
-require 'active_resource/exceptions'
-
 module ActiveResource # :nodoc:
   class Schema # :nodoc:
     # attributes can be known to be one of these types. They are easy to