nestful 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+*.gem

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alexander MacCaw (info@eribium.org)
+
+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.

data/README.markdown

@@ -0,0 +1,71 @@
+Nestful is a simple Ruby HTTP/REST client with a sane API. 
+
+## Features
+
+  * Simple API
+  * File buffering
+  * Before/Progress/After Callbacks
+  * JSON & XML requests
+  * Multipart requests (file uploading)
+  * Resource API
+  * Proxy support
+  * SSL support
+
+## Options
+
+Request options:
+
+  * headers (hash)
+  * params  (hash)
+  * buffer  (true/false)
+  * method  (:get/:post/:put/:delete/:head)
+
+Connection options:
+
+  * proxy
+  * user
+  * password
+  * auth_type
+  * timeout
+  * ssl_options
+
+## API
+  
+### GET request
+
+    Nestful.get 'http://example.com' #=> "body"
+
+### POST request
+
+    Nestful.post 'http://example.com', :format => :form #=> "body"
+    
+### Parameters
+
+    Nestful.get 'http://example.com', :params => {:nestled => {:params => 1}}
+
+### JSON request
+
+    Nestful.get 'http://example.com', :format => :json  #=> {:json_hash => 1}
+    Nestful.json_get 'http://example.com'               #=> {:json_hash => 1}
+    Nestful.post 'http://example.com', :format => :json, :params => {:q => 'test'} #=> {:json_hash => 1}
+  
+### Resource
+
+    Nestful::Resource.new('http://example.com')['assets'][1].get(:format => :xml) #=> {:xml_hash => 1}
+
+### Buffer download, return Tempfile
+
+    Nestful.get 'http://example.com/file.jpg', :buffer => true #=> <File ...>
+
+### Callbacks
+
+    Nestful.get 'http://www.google.co.uk', :buffer => true, :progress => Proc.new {|conn, total, size| p total; p size }
+    Nestful::Request.before_request {|conn| }
+    Nestful::Request.after_request {|conn, response| }
+
+### Multipart post
+
+    Nestful.post 'http://example.com', :format => :multipart, :params => {:file => File.open('README')}
+
+## Credits
+  Large parts of the connection code were taken from ActiveResource

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "nestful"
+    gemspec.summary = "Simple Ruby HTTP/REST client with a sane API"
+    gemspec.email = "info@eribium.org"
+    gemspec.homepage = "http://github.com/maccman/nestful"
+    gemspec.description = "Simple Ruby HTTP/REST client with a sane API"
+    gemspec.authors = ["Alex MacCaw"]
+    gemspec.add_dependency("activesupport", ">= 3.0.0.beta")
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/nestful/connection.rb

@@ -0,0 +1,306 @@
+require 'net/https'
+require 'date'
+require 'time'
+require 'uri'
+
+module Nestful
+  class Connection
+
+    HTTP_FORMAT_HEADER_NAMES = {  
+      :get => 'Accept',
+      :put => 'Content-Type',
+      :post => 'Content-Type',
+      :delete => 'Accept',
+      :head => 'Accept'
+    }
+
+    attr_reader :site, :user, :password, :auth_type, :timeout, :proxy, :ssl_options
+    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 = Formats::XmlFormat.new)
+      raise ArgumentError, 'Missing site URI' unless site
+      @user = @password = nil
+      @uri_parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+      self.site = site
+      self.format = format
+    end
+
+    # Set URI for remote service.
+    def site=(site)
+      @site = site.is_a?(URI) ? site : @uri_parser.parse(site)
+      @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)
+    end
+
+    # Sets the user for remote service.
+    def user=(user)
+      @user = user
+    end
+
+    # Sets the password for remote service.
+    def password=(password)
+      @password = password
+    end
+
+    # Sets the auth type for remote service.
+    def auth_type=(auth_type)
+      @auth_type = legitimize_auth_type(auth_type)
+    end
+
+    # Sets the number of seconds after which HTTP requests to the remote service should time out.
+    def timeout=(timeout)
+      @timeout = timeout
+    end
+
+    # Hash of options applied to Net::HTTP instance when +site+ protocol is 'https'.
+    def ssl_options=(opts={})
+      @ssl_options = opts
+    end
+
+    # Executes a GET request.
+    # Used to get (find) resources.
+    def get(path, headers = {}, &block)
+      with_auth { request(:get, path, build_request_headers(headers, :get, self.site.merge(path)), &block) }
+    end
+
+    # Executes a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(path, headers = {}, &block)
+      with_auth { request(:delete, path, build_request_headers(headers, :delete, self.site.merge(path)), &block) }
+    end
+
+    # Executes a PUT request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def put(path, body = '', headers = {}, &block)
+      with_auth { request(:put, path, body, build_request_headers(headers, :put, self.site.merge(path)), &block) }
+    end
+
+    # Executes a POST request.
+    # Used to create new resources.
+    def post(path, body = '', headers = {}, &block)
+      with_auth { request(:post, path, body, build_request_headers(headers, :post, self.site.merge(path)), &block) }
+    end
+
+    # Executes a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(path, headers = {}, &block)
+      with_auth { request(:head, path, build_request_headers(headers, :head, self.site.merge(path)), &block) }
+    end
+
+    private
+      # Makes a request to the remote service.
+      def request(method, path, *arguments)
+        body    = nil
+        body    = arguments.shift if [:put, :post].include?(method)
+        headers = arguments.shift || {}
+        
+        method = Net::HTTP.const_get(method.to_s.capitalize)
+        method = method.new(path)
+        
+        if body
+          if body.respond_to?(:read)
+            method.body_stream = body
+          else
+            method.body = body
+          end
+          
+          if body.respond_to?(:size)
+            headers['Content-Length'] ||= body.size
+          end
+        end
+        
+        headers.each {|name, value|
+          next unless value
+          method.add_field(name, value)
+        }
+        
+        http.start do |stream|
+          stream.request(method) {|rsp|
+            handle_response(rsp)
+            yield(rsp) if block_given?
+            rsp
+          }
+        end
+          
+      rescue Timeout::Error => e
+        raise TimeoutError.new(e.message)
+      rescue OpenSSL::SSL::SSLError => e
+        raise SSLError.new(e.message)
+      end
+
+      # Handles response and error codes from the 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 409
+            raise(ResourceConflict.new(response))
+          when 410
+            raise(ResourceGone.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 the
+      # remote service and resources.
+      def http
+        configure_http(new_http)
+      end
+
+      def new_http
+        if @proxy
+          Net::HTTP.new(@site.host, @site.port, @proxy.host, @proxy.port, @proxy.user, @proxy.password)
+        else
+          Net::HTTP.new(@site.host, @site.port)
+        end
+      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
+        end
+
+        http
+      end
+
+      def apply_ssl_options(http)
+        return http unless @site.is_a?(URI::HTTPS)
+
+        http.use_ssl     = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        return http unless defined?(@ssl_options)
+
+        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
+      end
+
+      def default_header
+        @default_header ||= {}
+      end
+
+      # Builds headers for request to remote service.
+      def build_request_headers(headers, http_method, uri)
+        authorization_header(http_method, uri).update(default_header).update(http_format_header(http_method)).update(headers)
+      end
+
+      def response_auth_header
+        @response_auth_header ||= ""
+      end
+
+      def with_auth
+        retried ||= false
+        yield
+      rescue UnauthorizedAccess => e
+        raise if retried || auth_type != :digest
+        @response_auth_header = e.response['WWW-Authenticate']
+        retried = true
+        retry
+      end
+
+      def authorization_header(http_method, uri)
+        if @user || @password
+          if auth_type == :digest
+            { 'Authorization' => digest_auth_header(http_method, uri) }
+          else
+            { 'Authorization' => 'Basic ' + ["#{@user}:#{@password}"].pack('m').delete("\r\n") }
+          end
+        else
+          {}
+        end
+      end
+
+      def digest_auth_header(http_method, uri)
+        params = extract_params_from_response
+
+        ha1 = Digest::MD5.hexdigest("#{@user}:#{params['realm']}:#{@password}")
+        ha2 = Digest::MD5.hexdigest("#{http_method.to_s.upcase}:#{uri.path}")
+
+        params.merge!('cnonce' => client_nonce)
+        request_digest = Digest::MD5.hexdigest([ha1, params['nonce'], "0", params['cnonce'], params['qop'], ha2].join(":"))
+        "Digest #{auth_attributes_for(uri, request_digest, params)}"
+      end
+
+      def client_nonce
+        Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
+      end
+
+      def extract_params_from_response
+        params = {}
+        if response_auth_header =~ /^(\w+) (.*)/
+          $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        end
+        params
+      end
+
+      def auth_attributes_for(uri, request_digest, params)
+        [
+          %Q(username="#{@user}"),
+          %Q(realm="#{params['realm']}"),
+          %Q(qop="#{params['qop']}"),
+          %Q(uri="#{uri.path}"),
+          %Q(nonce="#{params['nonce']}"),
+          %Q(nc="0"),
+          %Q(cnonce="#{params['cnonce']}"),
+          %Q(opaque="#{params['opaque']}"),
+          %Q(response="#{request_digest}")].join(", ")
+      end
+
+      def http_format_header(http_method)
+        {HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type}
+      end
+
+      def legitimize_auth_type(auth_type)
+        return :basic if auth_type.nil?
+        auth_type = auth_type.to_sym
+        [:basic, :digest].include?(auth_type) ? auth_type : :basic
+      end
+  end
+end

data/lib/nestful/exceptions.rb

@@ -0,0 +1,69 @@
+module Nestful
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      message = "Failed."
+      message << "  Response code = #{response.code}." if response.respond_to?(:code)
+      message << "  Response message = #{response.message}." if response.respond_to?(:message)
+      message
+    end
+  end
+
+  # Raised when a Timeout::Error occurs.
+  class TimeoutError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # Raised when a OpenSSL::SSL::SSLError occurs.
+  class SSLError < 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:
+
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 410 Gone
+  class ResourceGone < 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
+end

data/lib/nestful/formats/blank_format.rb

@@ -0,0 +1,13 @@
+module Nestful
+  module Formats
+    class BlankFormat < Format
+      def encode(params, options = nil)
+        raise "Choose an encoding format, such as :form"
+      end
+  
+      def decode(body)
+        body
+      end
+    end
+  end
+end

data/lib/nestful/formats/form_format.rb

@@ -0,0 +1,17 @@
+module Nestful
+  module Formats
+    class FormFormat < Format
+      def mime_type
+        "application/x-www-form-urlencoded"
+      end
+  
+      def encode(params, options = nil)
+        params.to_param
+      end
+  
+      def decode(body)
+        body
+      end
+    end
+  end
+end

data/lib/nestful/formats/json_format.rb

@@ -0,0 +1,24 @@
+require 'yaml'
+require 'active_support/json'
+
+module Nestful
+  module Formats
+    class JsonFormat < Format
+      def extension
+        "json"
+      end
+
+      def mime_type
+        "application/json"
+      end
+
+      def encode(hash, options = nil)
+        ActiveSupport::JSON.encode(hash, options)
+      end
+
+      def decode(json)
+        ActiveSupport::JSON.decode(json)
+      end
+    end
+  end
+end

data/lib/nestful/formats/multipart_format.rb

@@ -0,0 +1,77 @@
+require "active_support/secure_random"
+
+module Nestful
+  module Formats
+    class MultipartFormat < Format
+      EOL = "\r\n"
+      
+      attr_reader :boundary, :stream
+      
+      def initialize(*args)
+        super
+        @boundary = ActiveSupport::SecureRandom.hex(10)
+        @stream   = Tempfile.new("nf.#{rand(1000)}")
+        @stream.binmode
+      end
+
+      def mime_type
+        %Q{multipart/form-data; boundary=#{boundary}}
+      end
+
+      def encode(params, options = nil, namespace = nil)
+        to_multipart(params)
+        stream.write(EOL + "--" + boundary + "--" + EOL)
+        stream.flush
+        stream.rewind
+        stream
+      end
+
+      def decode(body)
+        body
+      end
+  
+      protected
+        def to_multipart(params, namespace = nil)
+          params.each do |key, value|
+            key = namespace ? "#{namespace}[#{key}]" : key
+
+            # Support nestled params
+            if value.is_a?(Hash)
+              to_multipart(value, key)
+              next
+            end
+
+            stream.write("--" + boundary + EOL)
+
+            if value.is_a?(File) || value.is_a?(StringIO)
+              create_file_field(key, value)
+            else
+              create_field(key, value)
+            end
+          end          
+        end
+      
+        def create_file_field(key, value)
+          stream.write(%Q{Content-Disposition: format-data; name="#{key}"; filename="#{filename(value)}"} + EOL)
+          stream.write(%Q{Content-Type: application/octet-stream} + EOL)
+          stream.write(%Q{Content-Transfer-Encoding: binary} + EOL)
+          stream.write(EOL)
+          while data = value.read(8124)
+            stream.write(data)
+          end
+        end
+    
+        def create_field(key, value)
+          stream.write(%Q{Content-Disposition: form-data; name="#{key}"} + EOL)
+          stream.write(EOL)
+          stream.write(value)
+        end
+  
+        def filename(body)
+          return body.original_filename   if body.respond_to?(:original_filename)
+          return File.basename(body.path) if body.respond_to?(:path)
+          "Unknown"
+        end
+    end
+  end
+end

data/lib/nestful/formats/xml_format.rb

@@ -0,0 +1,34 @@
+require 'active_support/core_ext/hash/conversions'
+
+module Nestful
+  module Formats
+    class XmlFormat < Format
+      def extension
+        "xml"
+      end
+
+      def mime_type
+        "application/xml"
+      end
+
+      def encode(hash, options={})
+        hash.to_xml(options)
+      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 Active Resource.
+        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/nestful/formats.rb

@@ -0,0 +1,31 @@
+module Nestful
+  module Formats
+    class Format
+      def extension
+      end
+
+      def mime_type
+      end
+      
+      def encode(*args)
+      end
+      
+      def decode(*args)
+      end
+    end
+    
+    autoload :BlankFormat, 'nestful/formats/blank_format'
+    autoload :MultipartFormat,  'nestful/formats/multipart_format'
+    autoload :FormFormat,  'nestful/formats/form_format'
+    autoload :XmlFormat,   'nestful/formats/xml_format'
+    autoload :JsonFormat,  'nestful/formats/json_format'
+    
+    # Lookup the format class from a mime type reference symbol. Example:
+    #
+    #   Nestful::Formats[:xml]  # => Nestful::Formats::XmlFormat
+    #   Nestful::Formats[:json] # => Nestful::Formats::JsonFormat
+    def self.[](mime_type_reference)
+      Nestful::Formats.const_get(ActiveSupport::Inflector.camelize(mime_type_reference.to_s) + "Format")
+    end
+  end  
+end

data/lib/nestful/request/callbacks.rb

@@ -0,0 +1,28 @@
+module Nestful
+  class Request
+    module Callbacks
+      CALLBACKS = [
+        :before_request, 
+        :after_request, 
+        :progress
+      ]
+      
+      def self.included(base)
+        CALLBACKS.each do |callback|
+          base.instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def #{callback}(method = nil, &block)
+              callbacks(:#{callback}) << (method||block)
+            end
+          EOS
+        
+          base.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def #{callback}(method = nil, &block)
+              callbacks(:#{callback}) << (method||block)
+            end
+            alias_method :#{callback}=, :#{callback}
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/nestful/request.rb

@@ -0,0 +1,119 @@
+module Nestful
+  class Request
+    def self.callbacks(type = nil) #:nodoc:
+      @callbacks ||= {}
+      return @callbacks unless type
+      @callbacks[type] ||= []
+    end
+    
+    attr_reader :url, :options, :format
+    attr_accessor :params, :body, :buffer, :method, :headers, :callbacks
+    
+    # Connection options
+    attr_accessor :proxy, :user, :password, :auth_type, :timeout, :ssl_options
+  
+    def initialize(url, options = {})
+      @url     = url
+      @options = options
+      @options.each {|key, val| 
+        method = "#{key}="
+        send(method, val) if respond_to?(method)
+      }
+      self.method  ||= :get
+      self.format  ||= :blank
+      self.headers ||= {}
+      self.params  ||= {}
+      self.body    ||= ''
+    end
+    
+    def format=(mime_or_format)
+      @format = mime_or_format.is_a?(Symbol) ?
+        Formats[mime_or_format].new : mime_or_format
+    end
+    
+    def connection
+      conn              = Connection.new(uri, format)
+      conn.proxy        = proxy if proxy
+      conn.user         = user if user
+      conn.password     = password if password
+      conn.auth_type    = auth_type if auth_type
+      conn.timeout      = timeout if timeout
+      conn.ssl_options  = ssl_options if ssl_options
+      conn
+    end
+    
+    def uri
+      http_url = url.match(/^http/) ? url : "http://#{url}"
+      uri      = URI.parse(http_url)
+      uri.path = "/" if uri.path.empty?
+      if format && format.extension
+        uri.path += ".#{format.extension}" 
+      end      
+      uri
+    end
+        
+    def path
+      uri.path
+    end
+    
+    def query_path
+      query_path = path
+      if params.any?
+        query_path += "?"
+        query_path += params.to_param
+      end
+      query_path
+    end
+    
+    def execute
+      callback(:before_request, self)
+      result = nil
+      if [:post, :put].include?(method)
+        connection.send(method, path, encoded, headers) {|res| result = decoded(res) }
+      else
+        connection.send(method, query_path, headers) {|res| result = decoded(res) }
+      end
+      callback(:after_request, self, result)
+      result
+    end
+            
+    protected    
+      def encoded
+        format.encode(params.any? ? params : body)
+      end
+
+      def decoded(result)
+        if buffer
+          data  = Tempfile.new("nfr.#{rand(1000)}")
+          size  = 0
+          total = result.content_length
+          
+          result.read_body {|chunk|
+            callback(:progress, self, total, size += chunk.size)
+            data.write(chunk)
+          }
+          
+          data.rewind
+          data
+        else
+          data = result.body
+          format ? format.decode(data) : data
+        end
+      end
+      
+      def callbacks(type = nil)
+        @callbacks ||= {}
+        return @callbacks unless type
+        @callbacks[type] ||= []
+      end
+    
+      def callback(type, *args)
+        procs = self.class.callbacks(type) + callbacks(type)
+        procs.compact.each {|c| c.call(*args) }
+      end
+  end
+  
+  class Request
+    include Callbacks
+  end
+end

data/lib/nestful/resource.rb

@@ -0,0 +1,30 @@
+module Nestful
+  class Resource
+    attr_reader :url
+    
+    def initialize(url, options = {})
+      @url     = url
+      @options = options
+    end
+    
+    def [](suburl)
+      self.class.new(URI.join(url, suburl).to_s)
+    end
+    
+    def get(options = {})
+      Nestful.get(url, options.merge(@options))
+    end
+
+    def post(options = {})
+      Nestful.post(url, options.merge(@options))
+    end
+    
+    def json_get(params = nil)
+      get(:format => :json, :params => params)
+    end
+    
+    def json_post(params = nil)
+      post(:format => :json, :params => params)
+    end
+  end
+end

data/lib/nestful.rb

@@ -0,0 +1,44 @@
+require "net/http"
+require "uri"
+require "tempfile"
+
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
+require "active_support/inflector"
+
+$:.unshift(File.dirname(__FILE__))
+
+require "nestful/exceptions"
+require "nestful/formats"
+require "nestful/connection"
+require "nestful/request/callbacks"
+require "nestful/request"
+require "nestful/resource"
+
+module Nestful
+  extend self
+
+  def get(url, options = {})
+    Request.new(url, options.merge(:method => :get)).execute
+  end
+    
+  def post(url, options = {})
+    Request.new(url, options.merge(:method => :post)).execute
+  end
+  
+  def put(url, options = {})
+    Request.new(url, options.merge(:method => :put)).execute
+  end
+  
+  def delete(url, options = {})
+    Request.new(url, options.merge(:method => :delete)).execute
+  end
+  
+  def json_get(url, params = nil)
+    get(url, :format => :json, :params => params)
+  end
+  
+  def json_post(url, params = nil)
+    post(url, :format => :json, :params => params)
+  end
+end

data/nestful.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{nestful}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex MacCaw"]
+  s.date = %q{2010-04-21}
+  s.description = %q{Simple Ruby HTTP/REST client with a sane API}
+  s.email = %q{info@eribium.org}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/nestful.rb",
+     "lib/nestful/connection.rb",
+     "lib/nestful/exceptions.rb",
+     "lib/nestful/formats.rb",
+     "lib/nestful/formats/blank_format.rb",
+     "lib/nestful/formats/form_format.rb",
+     "lib/nestful/formats/json_format.rb",
+     "lib/nestful/formats/multipart_format.rb",
+     "lib/nestful/formats/xml_format.rb",
+     "lib/nestful/request.rb",
+     "lib/nestful/request/callbacks.rb",
+     "lib/nestful/resource.rb",
+     "nestful.gemspec"
+  ]
+  s.homepage = %q{http://github.com/maccman/nestful}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Simple Ruby HTTP/REST client with a sane API}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+  end
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: nestful
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex MacCaw
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta
+        version: 3.0.0.beta
+  type: :runtime
+  version_requirements: *id001
+description: Simple Ruby HTTP/REST client with a sane API
+email: info@eribium.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/nestful.rb
+- lib/nestful/connection.rb
+- lib/nestful/exceptions.rb
+- lib/nestful/formats.rb
+- lib/nestful/formats/blank_format.rb
+- lib/nestful/formats/form_format.rb
+- lib/nestful/formats/json_format.rb
+- lib/nestful/formats/multipart_format.rb
+- lib/nestful/formats/xml_format.rb
+- lib/nestful/request.rb
+- lib/nestful/request/callbacks.rb
+- lib/nestful/resource.rb
+- nestful.gemspec
+has_rdoc: true
+homepage: http://github.com/maccman/nestful
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple Ruby HTTP/REST client with a sane API
+test_files: []
+