nestful 0.0.8 → 1.0.0.pre

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nestful.gemspec
+gemspec

data/README.markdown

@@ -1,4 +1,4 @@
-Nestful is a simple Ruby HTTP/REST client with a sane API. 
+Nestful is a simple Ruby HTTP/REST client with a sane API.
 
 ## Installation
 
@@ -9,19 +9,18 @@ Nestful is a simple Ruby HTTP/REST client with a sane API.
   * Simple API
   * File buffering
   * Before/Progress/After Callbacks
-  * JSON & XML requests
+  * JSON requests
   * Multipart requests (file uploading)
   * Resource API
   * Proxy support
   * SSL support
 
-## Options
+## Request Options
 
 Request options:
 
   * headers (hash)
   * params  (hash)
-  * buffer  (true/false)
   * method  (:get/:post/:put/:delete/:head)
 
 Connection options:
@@ -34,55 +33,30 @@ Connection options:
   * ssl_options
 
 ## API
-  
+
 ### GET request
 
     Nestful.get 'http://example.com' #=> "body"
 
 ### POST request
 
-    Nestful.post 'http://example.com', :format => :form #=> "body"
-
-other supported mime-type formats are :json, :multipart, :xml
+    Nestful.post 'http://example.com', :params => {:foo => 'bar'}
+    Nestful.post 'http://example.com', :params => {:foo => 'bar'}, :format => :json
 
 ### 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
-
-The Resource class provides a single object to work with restful services. The following example does a GET request to the URL; http://example.com/assets/1/
-
-    Nestful::Resource.new('http://example.com')['assets'][1].get(:format => :xml) #=> {:xml_hash => 1}
+### Endpoint
 
-The Resource class also supports, post, json_post and json_get methods.
+The `Endpoint` class provides a single object to work with restful services. The following example does a GET request to the URL; http://example.com/assets/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| }
+    Nestful::Endpoint.new('http://example.com')['assets'][1].get
 
 ### Multipart post
 
     Nestful.post 'http://example.com', :format => :multipart, :params => {:file => File.open('README')}
-    
-### OAuth
-
-Nestful uses ROAuth for OAuth support - check out supported options: http://github.com/maccman/roauth
-    
-    require 'nestful/oauth'
-    Nestful.get 'http://example.com', :oauth => {}
 
 ## Credits
-  Large parts of the connection code were taken from ActiveResource
+
+Large parts of the connection code were taken from ActiveResource

data/Rakefile

@@ -1,14 +1 @@
-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
+require "bundler/gem_tasks"

data/examples/resource.rb

@@ -0,0 +1,6 @@
+require 'nestful'
+
+class Charge < Nestful::Resource
+  url 'https://api.stripe.com/v1/charges'
+  options :auth_type => :bearer, :password => 'sk_test_mkGsLqEW6SLnZa487HYfJVLf'
+end

data/lib/nestful/connection.rb

@@ -1,306 +1,168 @@
 require 'net/https'
-require 'date'
-require 'time'
 require 'uri'
 
 module Nestful
   class Connection
+    UriParser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
 
-    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
+    attr_reader :site, :auth_type, :timeout, :proxy, :ssl_options
 
     # 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
+    def initialize(site, options = {})
       self.site = site
-      self.format = format
+
+      options.each do |key, value|
+        self.send("#{key}=", value) unless value.nil?
+      end
     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
+      @site = site.is_a?(URI) ? site : UriParser.parse(site)
     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
+      @proxy = proxy.is_a?(URI) ? proxy : UriParser.parse(proxy)
     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) }
+      request(:get, path, headers, &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) }
+      request(:delete, path, header, &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) }
+    def head(path, headers = {}, &block)
+      request(:head, path, headers, &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) }
+    def put(path, body = '', headers = {}, &block)
+      request(:put, path, body, headers, &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) }
+    def post(path, body = '', headers = {}, &block)
+      request(:post, path, body, headers, &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
+    protected
 
-      # 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
+    # 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 || {}
 
-      # Creates new Net::HTTP instance for communication with the
-      # remote service and resources.
-      def http
-        configure_http(new_http)
-      end
+      method = Net::HTTP.const_get(method.to_s.capitalize)
+      method = method.new(path)
 
-      def new_http
-        if @proxy
-          Net::HTTP.new(@site.host, @site.port, @proxy.host, @proxy.port, @proxy.user, @proxy.password)
+      if body
+        if body.respond_to?(:read)
+          method.body_stream = body
         else
-          Net::HTTP.new(@site.host, @site.port)
+          method.body = body
         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
+        if body.respond_to?(:size)
+          headers['Content-Length'] ||= body.size
         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
+      headers.each do |name, value|
+        next unless value
+        method.add_field(name, value)
       end
 
-      def default_header
-        @default_header ||= {}
+      http.start do |stream|
+        stream.request(method) do |rsp|
+          handle_response(rsp)
+          yield(rsp) if block_given?
+          rsp
+        end
       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
+    rescue Timeout::Error => e
+      raise TimeoutError.new(e.message)
+    rescue OpenSSL::SSL::SSLError => e
+      raise SSLError.new(e.message)
+    end
 
-      def response_auth_header
-        @response_auth_header ||= ""
+    # 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
 
-      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
+    # Creates new Net::HTTP instance for communication with the
+    # remote service and resources.
+    def http
+      configure_http(new_http)
+    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
+    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 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}")
+    def configure_http(http)
+      http = apply_ssl_options(http)
 
-        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)}"
+      # Net::HTTP timeouts default to 60 seconds.
+      if timeout
+        http.open_timeout = timeout
+        http.read_timeout = timeout
       end
 
-      def client_nonce
-        Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
-      end
+      http
+    end
 
-      def extract_params_from_response
-        params = {}
-        if response_auth_header =~ /^(\w+) (.*)/
-          $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
-        end
-        params
-      end
+    def apply_ssl_options(http)
+      return http unless site.is_a?(URI::HTTPS)
 
-      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
+      http.use_ssl     = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      return http unless ssl_options
 
-      def http_format_header(http_method)
-        {HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type}
+      ssl_options.each do |key, value|
+        http.send("#{key}=", value)
       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
+      http
+    end
   end
 end