nestful 1.0.0.pre → 1.0.0.rc1

data/README.markdown

@@ -7,56 +7,70 @@ Nestful is a simple Ruby HTTP/REST client with a sane API.
 ## Features
 
   * Simple API
-  * File buffering
-  * Before/Progress/After Callbacks
   * JSON requests
-  * Multipart requests (file uploading)
   * Resource API
   * Proxy support
   * SSL support
 
-## Request Options
+## API
+
+### GET request
+
+    Nestful.get 'http://example.com' #=> "body"
+
+### POST request
+
+    Nestful.post 'http://example.com', :foo => 'bar'
+    Nestful.post 'http://example.com', {:foo => 'bar'}, :format => :json
+
+### Parameters
+
+    Nestful.get 'http://example.com', :nestled => {:vars => 1}
+
+## Request
+
+`Request` is the base class for making HTTP requests - everthing else is just an abstraction upon it.
+
+    Request.new(url, options = {})
 
-Request options:
+Valid `Request` options are:
 
   * headers (hash)
   * params  (hash)
   * method  (:get/:post/:put/:delete/:head)
-
-Connection options:
-
   * proxy
   * user
   * password
-  * auth_type
+  * auth_type (:basic/:bearer)
   * timeout
   * ssl_options
 
-## API
-
-### GET request
-
-    Nestful.get 'http://example.com' #=> "body"
-
-### POST request
+## Endpoint
 
-    Nestful.post 'http://example.com', :params => {:foo => 'bar'}
-    Nestful.post 'http://example.com', :params => {:foo => 'bar'}, :format => :json
+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/
 
-### Parameters
+    Nestful::Endpoint.new('http://example.com')['assets'][1].get
 
-    Nestful.get 'http://example.com', :params => {:nestled => {:params => 1}}
+## Resource
 
-### Endpoint
+If you're building a binding for a REST API, then you should consider using the `Resource` class.
 
-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/
+    class Charge < Nestful::Resource
+      url 'https://api.stripe.com/v1/charges'
 
-    Nestful::Endpoint.new('http://example.com')['assets'][1].get
+      def self.all
+        self.new(get)
+      end
 
-### Multipart post
+      def self.find(id)
+        self.new(get(id))
+      end
 
-    Nestful.post 'http://example.com', :format => :multipart, :params => {:file => File.open('README')}
+      def refund
+        post(:refund)
+      end
+    end
 
 ## Credits
 
-Large parts of the connection code were taken from ActiveResource
+Parts of the connection code were taken from ActiveResource

data/examples/resource.rb

@@ -1,6 +1,27 @@
 require 'nestful'
 
-class Charge < Nestful::Resource
-  url 'https://api.stripe.com/v1/charges'
-  options :auth_type => :bearer, :password => 'sk_test_mkGsLqEW6SLnZa487HYfJVLf'
+# Example of using Stripe's API
+
+class Base < Nestful::Resource
+  endpoint 'https://api.stripe.com'
+  options :auth_type => :bearer, :password => ENV['SECRET_KEY']
+
+  def self.all(*args)
+    # We have to delve into the response,
+    # as Stripe doesn't return arrays for
+    # list responses.
+    self.new(Base.new(get('', *args)).data)
+  end
+
+  def self.find(id)
+    self.new(get(id))
+  end
+end
+
+class Charge < Base
+  path '/v1/charges'
+
+  def refund
+    post(:refund)
+  end
 end

data/lib/nestful/connection.rb

@@ -5,12 +5,12 @@ module Nestful
   class Connection
     UriParser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
 
-    attr_reader :site, :auth_type, :timeout, :proxy, :ssl_options
+    attr_reader :endpoint, :auth_type, :timeout, :proxy, :ssl_options
 
-    # The +site+ parameter is required and will set the +site+
+    # The +endpoint+ parameter is required and will set the +endpoint+
     # attribute to the URI for the remote resource service.
-    def initialize(site, options = {})
-      self.site = site
+    def initialize(endpoint, options = {})
+      self.endpoint = endpoint
 
       options.each do |key, value|
         self.send("#{key}=", value) unless value.nil?
@@ -18,8 +18,8 @@ module Nestful
     end
 
     # Set URI for remote service.
-    def site=(site)
-      @site = site.is_a?(URI) ? site : UriParser.parse(site)
+    def endpoint=(endpoint)
+      @endpoint = endpoint.is_a?(URI) ? endpoint : UriParser.parse(endpoint)
     end
 
     # Set the proxy for remote service.
@@ -51,37 +51,8 @@ module Nestful
 
     # 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 do |name, value|
-        next unless value
-        method.add_field(name, value)
-      end
-
-      http.start do |stream|
-        stream.request(method) do |rsp|
-          handle_response(rsp)
-          yield(rsp) if block_given?
-          rsp
-        end
-      end
+      response = http.send(method, path, *arguments)
+      handle_response(response)
 
     rescue Timeout::Error => e
       raise TimeoutError.new(e.message)
@@ -131,11 +102,11 @@ module Nestful
 
     def new_http
       if proxy
-        Net::HTTP.new(site.host, site.port,
+        Net::HTTP.new(endpoint.host, endpoint.port,
                       proxy.host, proxy.port,
                       proxy.user, proxy.password)
       else
-        Net::HTTP.new(site.host, site.port)
+        Net::HTTP.new(endpoint.host, endpoint.port)
       end
     end
 
@@ -152,7 +123,7 @@ module Nestful
     end
 
     def apply_ssl_options(http)
-      return http unless site.is_a?(URI::HTTPS)
+      return http unless endpoint.is_a?(URI::HTTPS)
 
       http.use_ssl     = true
       http.verify_mode = OpenSSL::SSL::VERIFY_NONE

data/lib/nestful/exceptions.rb

@@ -11,6 +11,7 @@ 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)
       message
     end
   end

data/lib/nestful/formats/json_format.rb

@@ -22,4 +22,4 @@ module Nestful
 
     JsonFormat = JSONFormat
   end
-end
+end

data/lib/nestful/helpers.rb

@@ -2,40 +2,24 @@ require 'cgi'
 
 module Nestful
   module Helpers extend self
-    def to_query(key, value)
-      case key
-      when Hash
-        "#{CGI.escape(to_param(key))}=#{CGI.escape(to_param(value))}"
-
-      when Array
-        prefix = "#{key}[]"
-        value.collect { |v| to_query(prefix, v) }.join('&')
-
+    def to_param(value, key = nil)
+      case value
+      when Hash  then value.map { |k,v| to_param(v, append_key(key,k)) }.join('&')
+      when Array then value.map { |v| to_param(v, "#{key}[]") }.join('&')
+      when nil   then ''
       else
-        value
-      end
-    end
-
-    def to_param(object, namespace = nil)
-      case object
-      when Hash
-        object.map do |key, value|
-          key = "#{namespace}[#{key}]" if namespace
-          to_query(key, value)
-        end.join('&')
-
-      when Array
-        object.each do |value|
-          to_param(value)
-        end.join('/')
-
-      else
-        value
+        "#{key}=#{CGI.escape(value.to_s)}"
       end
     end
 
     def camelize(value)
       value.to_s.split('_').map {|w| w.capitalize }.join
     end
+
+    protected
+
+    def append_key(root_key, key)
+      root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
+    end
   end
 end

data/lib/nestful/request.rb

@@ -35,13 +35,13 @@ module Nestful
     def uri
       return @uri if @uri
 
-      url = @url.match(/^http/) ? @url : "http://#{@url}"
+      url = @url.match(/\Ahttps?:\/\//) ? @url : "http://#{@url}"
 
       @uri = URI.parse(url)
-      @uri.path = "/" if @uri.path.empty?
+      @uri.path = '/' if @uri.path.empty?
 
-      @uri.query.split("&").each do |res|
-        key, value = res.split("=")
+      @uri.query.split('&').each do |res|
+        key, value = res.split('=')
         @params[key] = value
       end if @uri.query
 
@@ -53,16 +53,10 @@ module Nestful
     end
 
     def execute
-      result = nil
-
       if encoded?
-        connection.send(method, path, encoded, build_headers) do |res|
-          result = res
-        end
+        result = connection.send(method, path, encoded, build_headers)
       else
-        connection.send(method, query_path, build_headers) do |res|
-          result = res
-        end
+        result = connection.send(method, query_path, build_headers)
       end
 
       Response.new(result)

data/lib/nestful/resource.rb

@@ -4,82 +4,93 @@ module Nestful
   class Resource
     def self.endpoint(value = nil)
       @endpoint = value if value
-      @endpoint || ''
+      return @endpoint if @endpoint
+      superclass.respond_to?(:endpoint) ? superclass.endpoint : nil
     end
 
-    def self.url(value = nil)
-      @url = value if value
-      @url ? URI.join(endpoint, @url) : raise('Must define url')
+    def self.path(value = nil)
+      @path = value if value
+      return @path if @path
+      superclass.respond_to?(:path) ? superclass.path : nil
     end
 
     def self.options(value = nil)
       @options = value if value
-      @options || {}
+      return @options if @options
+      superclass.respond_to?(:options) ? superclass.options : nil
     end
 
-    def self.get(url, params = {}, options = {})
-      request(url, options.merge(:method => :get, :params => params))
+    def self.url
+      URI.join(endpoint.to_s, path.to_s).to_s
     end
 
-    def self.put(url, params = {}, options = {})
-      request(url, options.merge(:method => :put, :params => params))
+    def self.uri(*parts)
+      parts.unshift(path)
+      parts.unshift(endpoint)
+      URI.join(*parts.compact.map(&:to_s))
     end
 
-    def self.post(url, params = {}, options = {})
-      request(url, options.merge(:method => :post, :params => params))
+    def self.get(action = '', params = {}, options = {})
+      request(uri(action), options.merge(:method => :get, :params => params))
     end
 
-    def self.delete(url, params = {}, options = {})
-      request(url, options.merge(:method => :delete, :params => params))
+    def self.put(action = '', params = {}, options = {})
+      request(uri(action), options.merge(:method => :put, :params => params))
+    end
+
+    def self.post(action = '', params = {}, options = {})
+      request(uri(action), options.merge(:method => :post, :params => params))
+    end
+
+    def self.delete(action = '', params = {}, options = {})
+      request(uri(action), options.merge(:method => :delete, :params => params))
     end
 
     def self.request(url, options = {})
       Request.new(url, self.options.merge(options)).execute
     end
 
-    def self.all
-      self.new(get(url))
+    def self.all(*args)
+      self.new(get('', *args))
     end
 
     def self.find(id)
-      self.new(get(URI.join(url, id.to_s)))
+      self.new(get(id))
     end
 
-    def self.new(attributes = {}, options = {})
+    def self.new(attributes = {})
       if attributes.is_a?(Array)
-        attributes.map {|set| super(set, options) }
+        attributes.map {|set| super(set) }
       else
         super
       end
     end
 
-    attr_reader :attributes, :options
+    attr_reader :attributes
 
-    def initialize(attributes = {}, options = {})
-      @attributes = indifferent_attributes(attributes.to_hash)
-      @options    = self.class.options.merge(options)
+    def initialize(attributes = {})
+      @attributes = {}
+      load(attributes)
     end
 
-    def get(*args)
-      self.class.get(url, *args)
+    def get(action = '', *args)
+      self.class.get(uri(action), *args)
     end
 
-    def put(*args)
-      self.class.put(url, *args)
+    def put(action = '', *args)
+      self.class.put(uri(action), *args)
     end
 
-    def post(*args)
-      self.class.post(url, *args)
+    def post(action = '', *args)
+      self.class.post(uri(action), *args)
     end
 
-    def delete(*args)
-      self.class.delete(url, *args)
+    def delete(action = '', *args)
+      self.class.delete(uri(action), *args)
     end
 
-    alias_method :destroy, :delete
-
-    def url
-      URI.join(self.class.url, self.id.to_s)
+    def uri(*parts)
+      self.class.uri(self.id, *parts)
     end
 
     def id #:nodoc:
@@ -99,7 +110,7 @@ module Nestful
     end
 
     def to_hash
-      @attributes.dup
+      attributes.dup
     end
 
     alias_method :as_json, :to_hash
@@ -108,6 +119,12 @@ module Nestful
       as_json.to_json
     end
 
+    def load(attributes = {})
+      attributes.to_hash.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
     alias_method :respond_to_without_attributes?, :respond_to?
 
     def respond_to?(method, include_priv = false)
@@ -123,19 +140,6 @@ module Nestful
 
     protected
 
-    def indifferent_attributes(attributes)
-      attributes = indifferent_hash.merge(attributes)
-      attributes.each do |key, value|
-        next unless value.is_a?(Hash)
-        attributes[key] = indifferent_attributes(value)
-      end
-    end
-
-    # Creates a Hash with indifferent access.
-    def indifferent_hash
-      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-    end
-
     def method_missing(method_symbol, *arguments) #:nodoc:
       method_name = method_symbol.to_s
 

data/lib/nestful/version.rb

@@ -1,3 +1,3 @@
 module Nestful
-  VERSION = "1.0.0.pre"
+  VERSION = "1.0.0.rc1"
 end

data/lib/nestful.rb

@@ -16,15 +16,15 @@ module Nestful
     Endpoint[url].get(*args)
   end
 
-  def post(url, options = {})
+  def post(url, *args)
     Endpoint[url].post(*args)
   end
 
-  def put(url, options = {})
+  def put(url, *args)
     Endpoint[url].put(*args)
   end
 
-  def delete(url, options = {})
+  def delete(url, *args)
     Endpoint[url].delete(*args)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nestful
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre
+  version: 1.0.0.rc1
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-04 00:00:00.000000000 Z
+date: 2013-04-05 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -23,7 +23,6 @@ files:
 - MIT-LICENSE
 - README.markdown
 - Rakefile
-- VERSION
 - examples/resource.rb
 - lib/nestful.rb
 - lib/nestful/.DS_Store
@@ -33,7 +32,6 @@ files:
 - lib/nestful/formats.rb
 - lib/nestful/formats/form_format.rb
 - lib/nestful/formats/json_format.rb
-- lib/nestful/formats/multipart_format.rb
 - lib/nestful/helpers.rb
 - lib/nestful/request.rb
 - lib/nestful/resource.rb

data/VERSION

@@ -1 +0,0 @@
-0.0.8

data/lib/nestful/formats/multipart_format.rb

@@ -1,80 +0,0 @@
-require 'securerandom'
-require 'tempfile'
-
-module Nestful
-  module Formats
-    class MultipartFormat < Format
-      EOL = "\r\n"
-
-      attr_reader :boundary, :stream
-
-      def initialize(*args)
-        super
-        @boundary = 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)
-        to_multipart(params)
-        stream.write("--" + 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.respond_to?(:read)
-              create_file_field(key, value)
-            else
-              create_field(key, value)
-            end
-          end
-        end
-
-        def create_file_field(key, value)
-          stream.write(%Q{Content-Disposition: form-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
-          stream.write(EOL)
-        end
-
-        def create_field(key, value)
-          stream.write(%Q{Content-Disposition: form-data; name="#{key}"} + EOL)
-          stream.write(EOL)
-          stream.write(value)
-          stream.write(EOL)
-        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