Roman2K-web-service 0.1.1

data/lib/web_service/named_request_methods.rb

@@ -0,0 +1,19 @@
+module WebService
+  module NamedRequestMethods
+    def post(*args, &block)
+      request(:post, *args, &block).data
+    end
+    
+    def get(*args, &block)
+      request(:get, *args, &block).data
+    end
+    
+    def put(*args, &block)
+      request(:put, *args, &block).data
+    end
+    
+    def delete(*args, &block)
+      request(:delete, *args, &block).data
+    end
+  end
+end

data/lib/web_service/remote_collection.rb

@@ -0,0 +1,155 @@
+module WebService
+  class RemoteCollection
+    ARGUMENT_LAYOUT_FOR_REQUEST = [ [Integer, /^[^\/]/],  # ID
+                                    [Symbol,  /^\//],     # Action
+                                     Hash ].freeze        # Body
+    
+    # http://github.com/thoughtbot/suspenders/tree/master/config/initializers/errors.rb
+    HTTP_ERRORS = [ EOFError,
+                    Errno::EINVAL,
+                    Errno::ECONNRESET,
+                    Net::ProtocolError,
+                    Net::HTTPBadResponse,
+                    Net::HTTPHeaderSyntaxError ].freeze
+    
+    attr_reader :resource_class
+    attr_reader :nesting
+    
+    include ResponseHandling
+    
+    def initialize(resource_details, nesting=[])
+      @resource_class, @nesting = resource_details, nesting
+    end
+    
+    def request(method, *args)
+      id, action, body = recognize(ARGUMENT_LAYOUT_FOR_REQUEST, *args)
+      
+      url = build_url_for(id, action)
+      content_type, body = perform_adjustments_for_body!(body, method, url)
+      request = instantiate_request_for(method, url)
+      request.content_type = content_type if content_type
+      WebService.logger.info do
+        "#{method.to_s.upcase} #{url.obfuscate}#{" (#{body.length} bytes)" if body}"
+      end
+      response, elapsed = handle_connection_errors do
+        benchmark do
+          open_http_connection_to(url) do |conn|
+            conn.request(request, body).extend ResponseDataUnserialization
+          end
+        end
+      end
+      WebService.logger.info do
+        status = "=> %d %s"  % [response.code, response.message]
+        length = "(%.2f KB)" % [response.content_length / 1024.0] if response.content_length
+        time   = "[%d ms]"   % [elapsed * 1000]
+        [status, length, time].compact.join(' ')
+      end
+      handle_response(response)
+    end
+    
+    def with_nesting(further_nesting)
+      self.class.new(resource_class, nesting + further_nesting)
+    end
+    
+  private
+    
+    # Handle the body differently depending on the request method.
+    def build_url_for(id, action)
+      if resource_class.singleton
+        raise ArgumentError, "singleton resources do not require an ID parameter" if id
+      else
+        id ||= implicit_id if respond_to?(:implicit_id)
+      end
+      
+      url = ensure_url_copy(resource_class.site)
+      segments = [url.path]
+      nesting.each do |res_name, id_for_association|
+        segments << res_name.to_s.pluralize
+        raise "attribute `#{res_name}_id' is missing" unless id_for_association
+        segments << id_for_association
+      end
+      segments << (resource_class.singleton ? resource_class.element_name : resource_class.element_name.pluralize)
+      segments << (CGI.escape(id.to_s) if id) << action
+      url.path = segments.compact.join('/').squeeze('/')
+      return url
+    end
+    
+    def instantiate_request_for(method, url)
+      request = Net::HTTP.const_get(method.to_s.capitalize).new([url.path, url.query].compact.join('?'))
+      request.basic_auth(*resource_class.credentials) if resource_class.credentials
+      request['Accept'] = ["application/json", "application/xml"]
+      return request
+    end
+    
+    def perform_adjustments_for_body!(body, method, url)
+      case method
+      when :post, :put
+        ["application/json", body.to_json]
+      else
+        url.query = body.to_query if body.respond_to?(:to_query) && body.method(:to_query).arity <= 0
+        [nil, nil]
+      end
+    end
+    
+    def open_http_connection_to(url)
+      http = Net::HTTP.new(url.host, url.port)
+      http.open_timeout = http.read_timeout = 30
+      http.use_ssl = url.kind_of?(URI::HTTPS)
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+      http.start do |conn|
+        yield conn
+      end
+    end
+    
+    def handle_connection_errors
+      yield
+    rescue Timeout::Error
+      raise TimeoutError.new($!.message)
+    rescue *HTTP_ERRORS
+      raise ConnectionError.new(nil, $!.message)
+    end
+    
+  private # utilities
+    
+    def recognize(patterns, *objects)
+      patterns.map do |pattern|
+        if pos = objects.index { |object| case object; when *pattern; true; end }
+          objects.delete_at(pos)
+        end
+      end
+    end
+    
+    def benchmark
+      result = nil
+      elapsed = Benchmark.realtime do
+        result = yield
+      end
+      return result, elapsed
+    end
+  
+    def ensure_url_copy(url)
+      url = url.url if url.respond_to?(:url)
+      url.kind_of?(URI) ? url.dup : URI.parse(url)
+    end
+  
+    module ResponseDataUnserialization
+      def data
+        return @data if defined? @data
+        @data = parse_data
+      end
+      
+    private
+    
+      def parse_data
+        case content_type
+        when /json/
+          ActiveSupport::JSON.decode(body)
+        when /xml/
+          Hash.from_xml(body)
+        else
+          body.blank? ? nil : body
+        end
+      end
+    end
+  end
+end

data/lib/web_service/resource.rb

@@ -0,0 +1,177 @@
+module WebService
+  class Resource
+    class_inheritable_attr_accessor :site, :credentials
+    class_inheritable_attr_accessor :element_name, :singleton
+    
+    class << self
+      include NamedRequestMethods
+      include CRUDOperations
+      
+      def credentials
+        super || site.credentials
+      end
+      
+      def element_name
+        super || self.element_name = begin
+          klass = self
+          while klass.name.to_s.empty?
+            klass = klass.superclass
+            raise NameError, "cannot determine element name from anonymous class" unless klass < Resource
+          end
+          klass.name.to_s.demodulize.underscore
+        end
+      end
+
+      def belongs_to(*resource_names)
+        @belongs_to ||= []
+        @belongs_to |= resource_names
+        @belongs_to
+      end
+
+      def has_many(*resource_names)
+        resource_names.each do |res_name|
+          class_eval <<-RUBY
+            def #{res_name}
+              association_collection_from_name(#{res_name.to_sym.inspect})
+            end
+            def #{res_name}=(collection)
+              #{res_name}.cache = collection
+            end
+          RUBY
+        end
+      end
+      
+      def has_one(*resource_names)
+        resource_names.each do |res_name|
+          forwardings =
+            { "#{res_name}"       => :first,
+              "build_#{res_name}" => :build }
+          
+          forwardings.each do |from, to|
+            class_eval <<-RUBY
+              def #{from}(*args, &block)
+                association_collection_from_name(#{res_name.to_sym.inspect}, :singleton => true).#{to}(*args, &block)
+              end
+            RUBY
+          end
+        end
+      end
+      
+    protected
+    
+      delegate :request, :to => :remote_collection
+      
+      def remote_collection
+        @remote_collection ||= RemoteCollection.new(self)
+      end
+    end
+
+    include AttributeAccessors
+    include NamedRequestMethods
+    include CRUDOperations
+    
+    alias to_hash :attributes
+    
+    def to_s
+      [self.class, saved? ? "[#{id}]" : "(new)"].join
+    end
+    
+    def inspect
+      type_with_id = [self.class, saved? ? "[#{id}]" : "(new)"].join
+      displayable_attributes_pairs =
+        attributes.map { |name, value|
+          value = value[0, 22] + '...' if String === value && value.length > 25
+          "#{name}=#{value.inspect}" unless name == 'id'
+        }.compact.sort
+      "#<#{type_with_id}#{displayable_attributes_pairs.map { |pair| " " + pair }.join}>"
+    end
+    
+    def ==(other)
+      self.class === other && self.attributes == other.attributes
+    end
+    
+    def save
+      resource = if saved? then update((id unless self.class.singleton), attributes) else create(attributes) end
+      self.attributes = resource.attributes if resource
+      return self
+    end
+    
+    def saved?
+      respond_to?(:id) && id
+    end
+    
+    def reload
+      raise ResourceNotSaved unless saved?
+      id = self.id
+      [attribute_registry, association_registry].each &:clear
+      self.attributes = get(id)
+      return self
+    end
+    
+    def destroy
+      delete
+      return self
+    end
+    
+  protected # for CRUDOperations
+  
+    delegate :request, :to => :remote_collection
+    
+    def remote_collection
+      @remote_collection ||=
+        (@basic_remote_collection || self.class.instance_eval { remote_collection }).
+        with_nesting(nesting).
+        extend(ImplicitID).set_related_resource(self)
+    end
+    
+    def resource_class
+      self.class
+    end
+    
+  protected
+    
+    def association_collection_from_name(name, options={})
+      @association_collections ||= {}
+      @association_collections[name.to_sym] ||= build_association_collection_from_name(name, options)
+    end
+    
+  private
+  
+    def nesting
+      self.class.belongs_to.map { |res_name| [res_name, send("#{res_name}_id")] }
+    end
+    
+    def nesting_up_to_self
+      nesting + [[self.class.element_name, id]]
+    end
+    
+    def build_association_collection_from_name(name, options={})
+      if options[:singleton]
+        klass = name.to_s.camelize.constantize
+        klass.singleton ? klass : Class.new(klass) { self.singleton = true }
+      else
+        name.to_s.singularize.camelize.constantize
+      end.
+        instance_eval { remote_collection }.
+        with_nesting(nesting_up_to_self).
+        extend NamedRequestMethods, CRUDOperations, NestingAsImplicitAttributes
+    end
+    
+    module NestingAsImplicitAttributes
+      def implicit_attributes
+        nesting.inject({}) { |attributes, (res_name, id)| attributes.update("#{res_name}_id" => id) }
+      end
+    end
+    
+    module ImplicitID
+      def set_related_resource(resource)
+        @related_resource = resource
+        self
+      end
+      
+      def implicit_id
+        @related_resource.id if @related_resource.saved?
+      end
+    end
+  end
+end

data/lib/web_service/response_handling.rb

@@ -0,0 +1,148 @@
+# Copyright (c) 2006 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Extracted from ActiveResource 79f55de9c5e3ff1f8d9e767c5af21ba31be4cfba.
+module WebService
+  module ResponseHandling
+    module Exceptions
+      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
+
+      # Raised when a Timeout::Error occurs.
+      class TimeoutError < ConnectionError
+        def initialize(message)
+          @message = message
+        end
+        def to_s; @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:
+
+      # 400 Bad Request
+      class BadRequest < ClientError; end # :nodoc
+
+      # 401 Unauthorized
+      class UnauthorizedAccess < ClientError; end # :nodoc
+
+      # 403 Forbidden
+      class ForbiddenAccess < ClientError; end # :nodoc
+
+      # 404 Not Found
+      class ResourceNotFound < ClientError; end # :nodoc:
+      
+      # 406 Not Acceptable
+      class NotAcceptable < ClientError; end # :nodoc:
+
+      # 409 Conflict
+      class ResourceConflict < ClientError; end # :nodoc:
+    
+      # 422 Unprocessable Entity
+      class ResourceInvalid < ClientError; end #:nodoc:
+
+      # 5xx Server Error
+      class ServerError < ConnectionError; end # :nodoc:
+      
+      # 502 Bad Gateway
+      class BadGateway < ServerError; end # :nodoc:
+      
+      # 503 Service Unavailable
+      class ServiceUnavailable < ServerError; end # :nodoc:
+      
+      # 504 Gateway Timeout
+      class GatewayTimeout < ServerError; 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
+    end
+    include Exceptions
+  
+    # Fix ConnectionError message.
+    ConnectionError.class_eval do
+      def to_s
+        returning "Failed" do |message|
+          message << " with #{response.code}" if response && response.respond_to?(:code) && response.code
+          message << " (#{response.message})" if response && response.respond_to?(:message) && !response.message.to_s.strip.empty?
+          message << ": #{@message}" if @message
+        end
+      end
+    end
+  
+  protected
+    
+    # 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 400
+          raise BadRequest.new(response)
+        when 401
+          raise UnauthorizedAccess.new(response)
+        when 403
+          raise ForbiddenAccess.new(response)
+        when 404
+          raise ResourceNotFound.new(response)
+        when 405
+          raise MethodNotAllowed.new(response)
+        when 406
+          raise NotAcceptable.new(response)
+        when 409
+          raise ResourceConflict.new(response)
+        when 422
+          raise ResourceInvalid.new(response)
+        when 401...500
+          raise ClientError.new(response)
+        when 502
+          raise BadGateway.new(response)
+        when 503
+          raise ServiceUnavailable.new(response)
+        when 504
+          raise GatewayTimeout.new(response)
+        when 500...600
+          raise ServerError.new(response)
+        else
+          raise ConnectionError.new(response, "Unknown response code: #{response.code}")
+      end
+    end
+  end
+end