nestful 0.0.8 → 1.0.0.pre

data/lib/nestful/endpoint.rb

@@ -0,0 +1,42 @@
+module Nestful
+  class Endpoint
+    def self.[](url)
+      self.new(url)
+    end
+
+    attr_reader :url
+
+    def initialize(url, options = {})
+      @url     = url
+      @options = options
+    end
+
+    def [](suburl)
+      return self if suburl.nil?
+      suburl = suburl.to_s
+      base   = url
+      base  += "/" unless base =~ /\/$/
+      self.class.new(URI.join(base, suburl).to_s, @options)
+    end
+
+    def get(params = {}, options = {})
+      request(options.merge(:method => :get, :params => params))
+    end
+
+    def put(params = {}, options = {})
+      request(options.merge(:method => :put, :params => params))
+    end
+
+    def post(params = {}, options = {})
+      request(options.merge(:method => :post, :params => params))
+    end
+
+    def delete(params = {}, options = {})
+      request(options.merge(:method => :delete, :params => params))
+    end
+
+    def request(options = {})
+      Request.new(url, options.merge(@options)).execute
+    end
+  end
+end

data/lib/nestful/exceptions.rb

@@ -56,7 +56,7 @@ module Nestful
 
   # 410 Gone
   class ResourceGone < ClientError; end # :nodoc:
-  
+
   # 422 Invalid
   class ResourceInvalid < ClientError; end # :nodoc:
 

data/lib/nestful/formats/form_format.rb

@@ -4,11 +4,11 @@ module Nestful
       def mime_type
         'application/x-www-form-urlencoded'
       end
-  
+
       def encode(params, options = nil)
-        params.to_param
+        Helpers.to_param(params)
       end
-  
+
       def decode(body)
         body
       end

data/lib/nestful/formats/json_format.rb

@@ -1,24 +1,25 @@
-require 'yaml'
-require 'active_support/json'
+begin
+  require 'json'
+rescue LoadError => e
+  require 'json/pure'
+end
 
 module Nestful
   module Formats
-    class JsonFormat < Format
-      def extension
-        'json'
-      end
-
+    class JSONFormat < Format
       def mime_type
         'application/json'
       end
 
       def encode(hash, options = nil)
-        ActiveSupport::JSON.encode(hash, options)
+        hash.to_json(options)
       end
 
       def decode(json)
-        ActiveSupport::JSON.decode(json)
+        JSON.parse(json)
       end
     end
+
+    JsonFormat = JSONFormat
   end
 end

data/lib/nestful/formats/multipart_format.rb

@@ -1,12 +1,13 @@
 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)
@@ -29,7 +30,7 @@ module Nestful
       def decode(body)
         body
       end
-  
+
       protected
         def to_multipart(params, namespace = nil)
           params.each do |key, value|
@@ -43,14 +44,14 @@ module Nestful
 
             stream.write("--" + boundary + EOL)
 
-            if value.is_a?(File) || value.is_a?(StringIO) || value.is_a?(Tempfile)
+            if value.respond_to?(:read)
               create_file_field(key, value)
             else
               create_field(key, value)
             end
-          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)
@@ -61,14 +62,14 @@ module Nestful
           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)

data/lib/nestful/formats.rb

@@ -1,32 +1,35 @@
 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 :TextFormat,       'nestful/formats/text_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'
-    
+
+    MAPPING = {
+      'application/json' => :json
+    }
+
+    def self.for(type)
+      format = MAPPING[type]
+      format && self[format]
+    end
+
     # 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")
+      Nestful::Formats.const_get(Helpers.camelize(mime_type_reference.to_s) + 'Format')
     end
-  end  
+  end
 end
+
+Dir[File.dirname(__FILE__) + '/formats/*.rb'].sort.each do |path|
+  filename = File.basename(path)
+  require "nestful/formats/#{filename}"
+end

data/lib/nestful/helpers.rb

@@ -0,0 +1,41 @@
+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('&')
+
+      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
+      end
+    end
+
+    def camelize(value)
+      value.to_s.split('_').map {|w| w.capitalize }.join
+    end
+  end
+end

data/lib/nestful/request.rb

@@ -1,22 +1,16 @@
 module Nestful
   class Request
-    def self.callbacks(type = nil) #:nodoc:
-      @callbacks ||= {}
-      return @callbacks unless type
-      @callbacks[type] ||= []
-    end
-    
     attr_reader :options, :format, :url
-    attr_accessor :params, :body, :buffer, :method, :headers, :callbacks, :raw, :extension
-    
+    attr_accessor :params, :body, :method, :headers
+
     # Connection options
     attr_accessor :proxy, :user, :password, :auth_type, :timeout, :ssl_options
-  
+
     def initialize(url, options = {})
       @url     = url.to_s
-      
+
       @options = options
-      @options.each do |key, val| 
+      @options.each do |key, val|
         method = "#{key}="
         send(method, val) if respond_to?(method)
       end
@@ -24,127 +18,110 @@ module Nestful
       self.method  ||= :get
       self.params  ||= {}
       self.headers ||= {}
-      self.body    ||= ''
-      self.format  ||= :blank
+      self.format  ||= :form
     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
+        Formats[mime_or_format] : mime_or_format
     end
-    
+
     def url=(value)
       @url = value
       @uri = nil
       @url
     end
-        
+
     def uri
       return @uri if @uri
-      
+
       url = @url.match(/^http/) ? @url : "http://#{@url}"
-      
+
       @uri = URI.parse(url)
       @uri.path = "/" if @uri.path.empty?
-      
-      if extension
-        extension = format.extension if extension.is_a?(Boolean)
-        @uri.path += ".#{extension}"
-      end
-      
+
       @uri.query.split("&").each do |res|
         key, value = res.split("=")
         @params[key] = value
       end if @uri.query
-      
+
       @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) do |res| 
-          result = decoded(res)
-          result.class_eval { attr_accessor :response }
-          result.response = res
+
+      if encoded?
+        connection.send(method, path, encoded, build_headers) do |res|
+          result = res
         end
       else
-        connection.send(method, query_path, headers) do |res|
-          result = decoded(res) 
-          result.class_eval { attr_accessor :response }
-          result.response = res
+        connection.send(method, query_path, build_headers) do |res|
+          result = res
         end
       end
-      callback(:after_request, self, result)
-      result
+
+      Response.new(result)
+
     rescue Redirection => error
       self.url = error.response['Location']
       execute
     end
-            
+
     protected
-      def encoded
-        params.any? ? format.encode(params) : body
-      end
 
-      def decoded(result)
-        if buffer
-          data  = Tempfile.new("nfr.#{rand(1000)}")
-          size  = 0
-          total = result.content_length
-          
-          result.read_body do |chunk|
-            callback(:progress, self, total, size += chunk.size)
-            data.write(chunk)
-          end
-          
-          data.rewind
-          data
-        else
-          return result if raw
-          data = result.body
-          format ? format.decode(data) : data
-        end
+    def connection
+      Connection.new(uri,
+        :proxy       => proxy,
+        :timeout     => timeout,
+        :ssl_options => ssl_options
+      )
+    end
+
+    def content_type_headers
+      if encoded?
+        {'Content-Type' => format.mime_type}
+      else
+        {}
       end
-      
-      def callbacks(type = nil)
-        @callbacks ||= {}
-        return @callbacks unless type
-        @callbacks[type] ||= []
+    end
+
+    def auth_headers
+      if auth_type == :bearer
+        { 'Authorization' => "Bearer #{@password}" }
+      elsif auth_type == :basic
+        { 'Authorization' => 'Basic ' + ["#{@user}:#{@password}"].pack('m').delete("\r\n") }
+      else
+        { }
       end
-    
-      def callback(type, *args)
-        procs = self.class.callbacks(type) + callbacks(type)
-        procs.compact.each {|c| c.call(*args) }
+    end
+
+    def build_headers
+      auth_headers
+        .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
-  
-  class Request
-    include Callbacks
-  end
-end
+end