activeresource 2.0.1

data/lib/active_resource/connection.rb

@@ -0,0 +1,157 @@
+require 'net/https'
+require 'date'
+require 'time'
+require 'uri'
+require 'benchmark'
+
+module ActiveResource
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+  # 3xx Redirection
+  class Redirection < ConnectionError # :nodoc:
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end    
+  end 
+
+  # 4xx Client Error
+  class ClientError < ConnectionError; end # :nodoc:
+  
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+  
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 5xx Server Error
+  class ServerError < ConnectionError; end # :nodoc:
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+    def allowed_methods
+      @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+    end
+  end
+
+  # Class to handle connections to remote web services.
+  # This class is used by ActiveResource::Base to interface with REST
+  # services.
+  class Connection
+    attr_reader :site
+    attr_accessor :format
+
+    class << self
+      def requests
+        @@requests ||= []
+      end
+    end
+
+    # The +site+ parameter is required and will set the +site+
+    # attribute to the URI for the remote resource service.
+    def initialize(site, format = ActiveResource::Formats[:xml])
+      raise ArgumentError, 'Missing site URI' unless site
+      self.site = site
+      self.format = format
+    end
+
+    # Set URI for remote service.
+    def site=(site)
+      @site = site.is_a?(URI) ? site : URI.parse(site)
+    end
+
+    # Execute a GET request.
+    # Used to get (find) resources.
+    def get(path, headers = {})
+      format.decode(request(:get, path, build_request_headers(headers)).body)
+    end
+
+    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(path, headers = {})
+      request(:delete, path, build_request_headers(headers))
+    end
+
+    # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def put(path, body = '', headers = {})
+      request(:put, path, body.to_s, build_request_headers(headers))
+    end
+
+    # Execute a POST request.
+    # Used to create new resources.
+    def post(path, body = '', headers = {})
+      request(:post, path, body.to_s, build_request_headers(headers))
+    end
+
+
+    private
+      # Makes request to remote service.
+      def request(method, path, *arguments)
+        logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
+        result = nil
+        time = Benchmark.realtime { result = http.send(method, path, *arguments) }
+        logger.info "--> #{result.code} #{result.message} (#{result.body.length}b %.2fs)" % time if logger
+        handle_response(result)
+      end
+
+      # Handles response and error codes from remote service.
+      def handle_response(response)
+        case response.code.to_i
+          when 301,302
+            raise(Redirection.new(response))
+          when 200...400
+            response
+          when 404
+            raise(ResourceNotFound.new(response))
+          when 405
+            raise(MethodNotAllowed.new(response))
+          when 409
+            raise(ResourceConflict.new(response))
+          when 422
+            raise(ResourceInvalid.new(response))
+          when 401...500
+            raise(ClientError.new(response))
+          when 500...600
+            raise(ServerError.new(response))
+          else
+            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+        end
+      end
+
+      # Creates new Net::HTTP instance for communication with
+      # remote service and resources.
+      def http
+        http             = Net::HTTP.new(@site.host, @site.port)
+        http.use_ssl     = @site.is_a?(URI::HTTPS)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+        http
+      end
+
+      def default_header
+        @default_header ||= { 'Content-Type' => format.mime_type }
+      end
+      
+      # Builds headers for request to remote service.
+      def build_request_headers(headers)
+        authorization_header.update(default_header).update(headers)
+      end
+      
+      # Sets authorization header; authentication information is pulled from credentials provided with site URI.
+      def authorization_header
+        (@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
+      end
+
+      def logger #:nodoc:
+        ActiveResource::Base.logger
+      end
+  end
+end

data/lib/active_resource/custom_methods.rb

@@ -0,0 +1,105 @@
+# 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, 
+# say you use Rails to expose a REST service and configure your routes with:
+#
+#    map.resources :people, :new => { :register => :post },
+#                           :element => { :promote => :put, :deactivate => :delete }
+#                           :collection => { :active => :get }
+#
+#  This route set creates routes for the following http requests:
+#
+#    POST    /people/new/register.xml #=> PeopleController.register
+#    PUT     /people/1/promote.xml    #=> PeopleController.promote with :id => 1
+#    DELETE  /people/1/deactivate.xml #=> PeopleController.deactivate with :id => 1
+#    GET     /people/active.xml       #=> 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"
+#   end
+#
+#   Person.new(:name => 'Ryan).post(:register)  # POST /people/new/register.xml
+#   # => { :id => 1, :name => 'Ryan' }
+#
+#   Person.find(1).put(:promote, :position => 'Manager') # PUT /people/1/promote.xml
+#   Person.find(1).delete(:deactivate) # DELETE /people/1/deactivate.xml
+#
+#   Person.get(:active)  # GET /people/active.xml 
+#   # => [{:id => 1, :name => 'Ryan'}, {:id => 2, :name => 'Joe'}]
+#
+module ActiveResource
+  module CustomMethods 
+    def self.included(within)
+      within.class_eval do
+        extend ActiveResource::CustomMethods::ClassMethods
+        include ActiveResource::CustomMethods::InstanceMethods
+
+        class << self
+          alias :orig_delete :delete
+
+          def get(method_name, options = {})
+            connection.get(custom_method_collection_url(method_name, options), headers)
+          end
+
+          def post(method_name, options = {}, body = '')
+            connection.post(custom_method_collection_url(method_name, options), body, headers)
+          end
+
+          def put(method_name, options = {}, body = '')
+            connection.put(custom_method_collection_url(method_name, options), body, headers)
+          end
+
+          # Need to jump through some hoops to retain the original class 'delete' method
+          def delete(custom_method_name, options = {})
+            if (custom_method_name.is_a?(Symbol))
+              connection.delete(custom_method_collection_url(custom_method_name, options), headers)
+            else
+              orig_delete(custom_method_name, options)
+            end
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def custom_method_collection_url(method_name, options = {})
+        prefix_options, query_options = split_options(options)
+        "#{prefix(prefix_options)}#{collection_name}/#{method_name}.xml#{query_string(query_options)}"
+      end
+    end
+    
+    module InstanceMethods
+      def get(method_name, options = {})
+        connection.get(custom_method_element_url(method_name, options), self.class.headers)
+      end
+      
+      def post(method_name, options = {}, body = '')
+        if new?
+          connection.post(custom_method_new_element_url(method_name, options), (body.nil? ? to_xml : body), self.class.headers)
+        else
+          connection.post(custom_method_element_url(method_name, options), body, self.class.headers)
+        end
+      end
+      
+      def put(method_name, options = {}, body = '')
+        connection.put(custom_method_element_url(method_name, options), body, self.class.headers)
+      end
+      
+      def delete(method_name, options = {})
+        connection.delete(custom_method_element_url(method_name, options), self.class.headers)
+      end
+
+
+      private
+        def custom_method_element_url(method_name, options = {})
+          "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}.xml#{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}.xml#{self.class.send!(:query_string, options)}"
+        end
+    end
+  end
+end

data/lib/active_resource/formats.rb

@@ -0,0 +1,14 @@
+module ActiveResource
+  module Formats
+    # Lookup the format class from a mime type reference symbol. Example:
+    #
+    #   ActiveResource::Formats[:xml]  # => ActiveResource::Formats::XmlFormat
+    #   ActiveResource::Formats[:json] # => ActiveResource::Formats::JsonFormat
+    def self.[](mime_type_reference)
+      ActiveResource::Formats.const_get(mime_type_reference.to_s.camelize + "Format")
+    end
+  end
+end
+
+require 'active_resource/formats/xml_format'
+require 'active_resource/formats/json_format'

data/lib/active_resource/formats/json_format.rb

@@ -0,0 +1,23 @@
+module ActiveResource
+  module Formats
+    module JsonFormat
+      extend self
+      
+      def extension
+        "json"
+      end
+      
+      def mime_type
+        "application/json"
+      end
+      
+      def encode(hash)
+        hash.to_json
+      end
+      
+      def decode(json)
+        ActiveSupport::JSON.decode(json)
+      end
+    end
+  end
+end

data/lib/active_resource/formats/xml_format.rb

@@ -0,0 +1,34 @@
+module ActiveResource
+  module Formats
+    module XmlFormat
+      extend self
+      
+      def extension
+        "xml"
+      end
+      
+      def mime_type
+        "application/xml"
+      end
+      
+      def encode(hash)
+        hash.to_xml
+      end
+      
+      def decode(xml)
+        from_xml_data(Hash.from_xml(xml))
+      end
+      
+      private
+        # Manipulate from_xml Hash, because xml_simple is not exactly what we
+        # want for ActiveResource.
+        def from_xml_data(data)
+          if data.is_a?(Hash) && data.keys.size == 1
+            data.values.first
+          else
+            data
+          end
+        end      
+    end
+  end
+end

data/lib/active_resource/http_mock.rb

@@ -0,0 +1,136 @@
+require 'active_resource/connection'
+
+module ActiveResource
+  class InvalidRequestError < StandardError; end #:nodoc:
+
+  class HttpMock
+    class Responder
+      def initialize(responses)
+        @responses = responses
+      end
+
+      for method in [ :post, :put, :get, :delete ]
+        module_eval <<-EOE
+          def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {})
+            @responses[Request.new(:#{method}, path, nil, request_headers)] = Response.new(body || "", status, response_headers)
+          end
+        EOE
+      end
+    end
+
+    class << self
+      def requests
+        @@requests ||= []
+      end
+
+      def responses
+        @@responses ||= {}
+      end
+
+      def respond_to(pairs = {})
+        reset!
+        pairs.each do |(path, response)|
+          responses[path] = response
+        end
+
+        if block_given?
+          yield Responder.new(responses) 
+        else
+          Responder.new(responses)
+        end
+      end
+
+      def reset!
+        requests.clear
+        responses.clear
+      end
+    end
+
+    for method in [ :post, :put ]
+      module_eval <<-EOE
+        def #{method}(path, body, headers)
+          request = ActiveResource::Request.new(:#{method}, path, body, headers)
+          self.class.requests << request
+          self.class.responses[request] || raise(InvalidRequestError.new("No response recorded for: \#{request.inspect}"))
+        end
+      EOE
+    end
+
+    for method in [ :get, :delete ]
+      module_eval <<-EOE
+        def #{method}(path, headers)
+          request = ActiveResource::Request.new(:#{method}, path, nil, headers)
+          self.class.requests << request
+          self.class.responses[request] || raise(InvalidRequestError.new("No response recorded for: \#{request.inspect}"))
+        end
+      EOE
+    end
+
+    def initialize(site)
+      @site = site
+    end
+  end
+
+  class Request
+    attr_accessor :path, :method, :body, :headers
+
+    def initialize(method, path, body = nil, headers = {})
+      @method, @path, @body, @headers = method, path, body, headers.dup
+      @headers.update('Content-Type' => 'application/xml')
+    end
+
+    def ==(other_request)
+      other_request.hash == hash
+    end
+
+    def eql?(other_request)
+      self == other_request
+    end
+
+    def to_s
+      "<#{method.to_s.upcase}: #{path} [#{headers}] (#{body})>"
+    end
+
+    def hash
+      "#{path}#{method}#{headers}".hash
+    end
+  end
+
+  class Response
+    attr_accessor :body, :message, :code, :headers
+
+    def initialize(body, message = 200, headers = {})
+      @body, @message, @headers = body, message.to_s, headers
+      @code = @message[0,3].to_i
+    end
+
+    def success?
+      (200..299).include?(code)
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def []=(key, value)
+      headers[key] = value
+    end
+    
+    def ==(other)
+      if (other.is_a?(Response))
+        other.body == body && other.message == message && other.headers == headers
+      else
+        false
+      end
+    end
+  end
+
+  class Connection
+    private
+      silence_warnings do
+        def http
+          @http ||= HttpMock.new(@site)
+        end
+      end
+  end
+end