nestful 1.0.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39b78f8d5346095d86fb0c3f12840b2239aa06dc
-  data.tar.gz: f05421aa7dbf52811fba5552315087aec3df3f12
+  metadata.gz: bd97aa5fb848801d10cc36bfcc8a1f1d3997393e
+  data.tar.gz: a7f428dd9f1d1f363e8834f5180511d2eeec7036
 SHA512:
-  metadata.gz: db3c0bbefc9e9e5b031f070f4735b50dd2970adb6b5b50a7eb6787f5d4478b96cc08952c16a5d56fd4241a3a643637301b863e512b9131207149d6302895f9ec
-  data.tar.gz: d6d34a808b5417bdde3a0e92aed856822e6835a577aec77d9d38cf04836f2b71fe9285bf526d4ca69be5c17afbd29139259d5523deae495c0d85b717cfd9c89a
+  metadata.gz: 28b12558ec65700945a6a594a42710174114e3f87c56350aca183265d3be2a1e41ffb24db9468a81dbe17618982733d401395e65c0ce65710c7578c1182d6244
+  data.tar.gz: 2e10eec7723fbfb4cb5f291b7a904c1ce0e1f81927a5705a8332e41d7f5d171bfe6af8007f23b7fcf6574059679b5fb79f76fa8be43117d3824f60a25e26bb21

data/Gemfile

@@ -6,4 +6,5 @@ gemspec
 group :test do
   gem 'webmock'
   gem 'rake'
+  gem 'net-http-spy'
 end

data/lib/nestful/connection.rb

@@ -53,45 +53,65 @@ module Nestful
     # Makes a request to the remote service.
     def request(method, path, *arguments)
       response = http.send(method, path, *arguments)
+      response.uri = URI.join(endpoint, path)
+
       handle_response(response)
 
-    rescue Timeout::Error => e
+    rescue Timeout::Error, Net::OpenTimeout => e
       raise TimeoutError.new(e.message)
     rescue OpenSSL::SSL::SSLError => e
       raise SSLError.new(e.message)
+    rescue SocketError,
+           EOFError,
+           Net::HTTPBadResponse,
+           Net::HTTPHeaderSyntaxError,
+           Net::HTTPServerException,
+           Net::ProtocolError,
+           Errno::ECONNABORTED,
+           Errno::ECONNREFUSED,
+           Errno::ECONNRESET,
+           Errno::ETIMEDOUT,
+           Errno::ENETUNREACH,
+           Errno::EHOSTUNREACH,
+           Errno::EINVAL,
+           Errno::ENOPROTOOPT => e
+      raise ErrnoError.new(e.message)
+    rescue Zlib::DataError,
+           Zlib::BufError => e
+      raise ZlibError.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}"
-          )
+      when 200...299
+        response
+      when 300..399
+        raise Redirection.new(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 ResponseError.new(
+          response, "Unknown response code: #{response.code}"
+        )
       end
     end
 
@@ -137,4 +157,4 @@ module Nestful
       http
     end
   end
-end
+end

data/lib/nestful/exceptions.rb

@@ -1,5 +1,18 @@
 module Nestful
-  class ConnectionError < StandardError # :nodoc:
+  class Error < StandardError; end
+  ConnectionError = Error
+
+  class RequestError < Error
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  class ResponseError < Error
     attr_reader :response
 
     def initialize(response, message = nil)
@@ -11,34 +24,43 @@ module Nestful
       message = "Failed."
       message << "  Response code = #{response.code}." if response.respond_to?(:code)
       message << "  Response message = #{response.message}." if response.respond_to?(:message)
-      message << "  Response Body = #{response.body}." if response.respond_to?(:body)
+
+      if response.respond_to?(:body)
+        # Error messages need to be in UTF-8
+        body = response.body.dup.to_s
+        body = body.encode('UTF-8', :invalid => :replace, :undef => :replace, :replace => '?')
+        message << "  Response Body = #{body}."
+      end
+
       message
     end
   end
 
   # Raised when a Timeout::Error occurs.
-  class TimeoutError < ConnectionError
-    def initialize(message)
-      @message = message
-    end
-    def to_s; @message ;end
+  class TimeoutError < RequestError
   end
 
   # Raised when a OpenSSL::SSL::SSLError occurs.
-  class SSLError < ConnectionError
-    def initialize(message)
-      @message = message
-    end
-    def to_s; @message ;end
+  class SSLError < RequestError
+  end
+
+  class ErrnoError < RequestError
+  end
+
+  class ZlibError < RequestError
   end
 
   # 3xx Redirection
-  class Redirection < ConnectionError # :nodoc:
+  class Redirection < ResponseError # :nodoc:
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
+  end
+
+  class RedirectionLoop < ResponseError # :nodoc:
     def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
   end
 
   # 4xx Client Error
-  class ClientError < ConnectionError; end # :nodoc:
+  class ClientError < ResponseError; end # :nodoc:
 
   # 400 Bad Request
   class BadRequest < ClientError; end # :nodoc
@@ -62,7 +84,7 @@ module Nestful
   class ResourceInvalid < ClientError; end # :nodoc:
 
   # 5xx Server Error
-  class ServerError < ConnectionError; end # :nodoc:
+  class ServerError < ResponseError; end # :nodoc:
 
   # 405 Method Not Allowed
   class MethodNotAllowed < ClientError # :nodoc:
@@ -70,4 +92,4 @@ module Nestful
       @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
     end
   end
-end
+end

data/lib/nestful/helpers.rb

@@ -38,6 +38,22 @@ module Nestful
       end
     end
 
+    def to_url_param(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          to_url_param(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          to_url_param(v, prefix ? "#{prefix}[#{uri_escape(k)}]" : uri_escape(k))
+        }.join("&")
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{uri_escape(value)}"
+      end
+    end
+
     def from_param(param)
       Rack::Utils.parse_nested_query(param)
       (value || '').split('&').each do |res|
@@ -59,7 +75,15 @@ module Nestful
     end
 
     def escape(s)
-      URI.encode_www_form_component(s)
+      URI.encode_www_form_component(s.to_s)
+    end
+
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
+
+    def uri_escape(s)
+      s.to_s.gsub(ESCAPE_RE) {|match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      }.tr(' ', '+')
     end
 
     if defined?(::Encoding)
@@ -105,4 +129,4 @@ module Nestful
       return params
     end
   end
-end
+end

data/lib/nestful/mash.rb

@@ -1,42 +1,38 @@
 module Nestful
   class Mash < Hash
-    def self.get(*args)
-      from_response(Nestful.get(*args))
+    def self.get(action = '', params = {}, options = {})
+      request(action, options.merge(:method => :get, :params => params))
     end
 
-    def self.post(*args)
-      from_response(Nestful.post(*args))
+    def self.put(action = '', params = {}, options = {})
+      request(action, options.merge(:method => :put, :params => params))
     end
 
-    def self.put(*args)
-      from_response(Nestful.put(*args))
+    def self.post(action = '', params = {}, options = {})
+      request(action, options.merge(:method => :post, :params => params))
     end
 
-    def self.delete(*args)
-      from_response(Nestful.delete(*args))
+    def self.delete(action = '', params = {}, options = {})
+      request(action, options.merge(:method => :delete, :params => params))
     end
 
-    def self.request(*args)
-      from_response(Nestful.request(*args))
+    def self.request(url, options = {})
+      self.new Request.new(url, options).execute
     end
 
-    def self.from_response(response)
-      case response.decoded
-      when Hash
-        self.new(response.decoded)
-      when Array
-        response.decoded.map {|v| self.new(v) }
+    def self.new(value = nil, *args)
+      if value.respond_to?(:each) &&
+        !value.respond_to?(:each_pair)
+        value.map {|v| super(v) }
       else
-        response
+        super
       end
     end
 
     alias_method :to_s, :inspect
 
-    attr_reader :response
-
     def initialize(source_hash = nil, default = nil, &blk)
-      deep_update(source_hash) if source_hash
+      deep_update(source_hash.to_hash) if source_hash
       default ? super(default) : super(&blk)
     end
 
@@ -191,13 +187,11 @@ module Nestful
       case val
         when self.class
           val.dup
-        when Hash
-          duping ? val.dup : val
         when ::Hash
           val = val.dup if duping
-          self.class.new(val)
-        when Array
-          val.collect{ |e| convert_value(e) }
+          Mash.new(val)
+        when ::Array
+          val.map {|e| convert_value(e) }
         else
           val
       end

data/lib/nestful/request.rb

@@ -1,24 +1,28 @@
 module Nestful
   class Request
     attr_reader :options, :format, :url
-    attr_accessor :params, :body, :method, :headers
 
-    # Connection options
-    attr_accessor :proxy, :user, :password, :auth_type, :timeout, :ssl_options
+    attr_accessor :params, :body, :method, :headers,
+                  :proxy, :user, :password,
+                  :auth_type, :timeout, :ssl_options,
+                  :max_attempts, :follow_redirection
 
     def initialize(url, options = {})
       @url     = url.to_s
 
-      @options = options
+      @options = {
+        :method           => :get,
+        :params           => {},
+        :headers          => {},
+        :format           => :form,
+        :max_attempts     => 5,
+        :follow_redirection => true
+      }.merge(options)
+
       @options.each do |key, val|
         method = "#{key}="
         send(method, val) if respond_to?(method)
       end
-
-      self.method  ||= :get
-      self.params  ||= {}
-      self.headers ||= {}
-      self.format  ||= :form
     end
 
     def format=(mime_or_format)
@@ -40,34 +44,77 @@ module Nestful
       @uri = URI.parse(url)
       @uri.path = '/' if @uri.path.empty?
 
-      if @uri.query
-        @params.merge!(Helpers.from_param(@uri.query))
-        @uri.query = nil
-      end
-
       @uri
     end
 
+    def uri_params
+      uri.query ? Helpers.from_param(uri.query) : {}
+    end
+
     def path
       uri.path
     end
 
-    def execute
-      if encoded?
-        result = connection.send(method, path, encoded, build_headers)
-      else
-        result = connection.send(method, query_path, build_headers)
+    def query_path
+      query_path   = path.dup
+      query_params = uri_params.dup
+      query_params.merge!(params) unless encoded?
+
+      if query_params.any?
+        query_path += '?' + Helpers.to_url_param(query_params)
       end
 
-      Response.new(result)
+      query_path
+    end
+
+    def encoded?
+      [:post, :put].include?(method)
+    end
+
+    def encoded
+      params.any? ? format.encode(params) : body
+    end
 
-    rescue Redirection => error
-      self.url = error.response['Location']
-      execute
+    def execute
+      with_redirection do
+        if encoded?
+          result = connection.send(method, query_path, encoded, build_headers)
+        else
+          result = connection.send(method, query_path, build_headers)
+        end
+
+        Response.new(result, uri)
+      end
     end
 
     protected
 
+    def with_redirection(&block)
+      attempts = 1
+
+      begin
+        yield
+      rescue Redirection => error
+        raise error unless follow_redirection
+
+        attempts += 1
+
+        raise error unless error.response['Location']
+        raise RedirectionLoop.new(error.response) if attempts > max_attempts
+
+        location = error.response['Location'].scrub
+        location = URI.parse(location)
+
+        # Path is relative
+        unless location.host
+          location = URI.join(uri, location)
+        end
+
+        self.url = location.to_s
+        retry
+      end
+    end
+
     def connection
       Connection.new(uri,
         :proxy       => proxy,
@@ -99,23 +146,5 @@ module Nestful
         .merge(content_type_headers)
         .merge(headers)
     end
-
-    def query_path
-      query_path = path
-
-      if params.any?
-        query_path += '?' + Helpers.to_param(params)
-      end
-
-      query_path
-    end
-
-    def encoded?
-      [:post, :put].include?(method)
-    end
-
-    def encoded
-      params.any? ? format.encode(params) : body
-    end
   end
-end
+end

data/lib/nestful/response.rb

@@ -1,15 +1,20 @@
 module Nestful
   class Response
-    attr_reader :response, :body, :headers, :parser
+    attr_reader :response, :location, :body, :headers, :parser
 
-    def initialize(response, parser = nil)
+    def initialize(response, location = nil)
       @response = response
       @body     = response.body
+      @location = location
       @headers  = Headers.new(response.to_hash)
       @format   = Formats.for(headers.content_type)
       @parser ||= @format && @format.new
     end
 
+    def to_s
+      body
+    end
+
     def as_json
       decoded
     end
@@ -46,4 +51,4 @@ module Nestful
   end
 end
 
-require 'nestful/response/headers'
+require 'nestful/response/headers'

data/lib/nestful/version.rb

@@ -1,3 +1,3 @@
 module Nestful
-  VERSION = "1.0.7"
+  VERSION = "1.1.0"
 end

data/test/nestful/test_request.rb

@@ -59,6 +59,12 @@ class TestRequest < MiniTest::Unit::TestCase
     assert_requested(:post, 'http://example.com/v1/tokens', :body => '{"card":{"number":4242,"exp_month":12}}', :headers => {'Content-Type' => 'application/json'})
   end
 
+  def test_form_and_query_params
+    stub_request(:any, 'http://example.com/v1/tokens?query=123')
+    Nestful::Request.new('http://example.com/v1/tokens?query=123', :method => :post, :params => {:number => 4242, :exp_month => 12}).execute
+    assert_requested(:post, 'http://example.com/v1/tokens?query=123', :body => 'number=4242&exp_month=12')
+  end
+
   def test_timeout
     skip # TODO
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nestful
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.1.0
 platform: ruby
 authors:
 - Alex MacCaw
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-07 00:00:00.000000000 Z
+date: 2015-07-09 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -17,7 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - MIT-LICENSE
 - README.markdown
@@ -26,7 +26,6 @@ files:
 - examples/pagespeed.rb
 - examples/resource.rb
 - lib/nestful.rb
-- lib/nestful/.DS_Store
 - lib/nestful/connection.rb
 - lib/nestful/endpoint.rb
 - lib/nestful/exceptions.rb
@@ -54,17 +53,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple Ruby HTTP/REST client with a sane API
@@ -73,3 +72,4 @@ test_files:
 - test/nestful/test_request.rb
 - test/nestful/test_resource.rb
 - test/nestful/test_response.rb
+has_rdoc: