restfulie 0.9.3 → 1.0.0.beta1

data/lib/restfulie/client/http/request_adapter.rb

@@ -1,213 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      # Request Adapter provides a minimal interface to exchange information between server over HTTP protocol through simple adapters.
-      # 
-      # All the concrete adapters follow the interface laid down in this module.
-      # Default connection provider is net/http
-      #
-      #==Example
-      #
-      #   @re = ::Restfulie::Client::HTTP::RequestExecutor.new('http://restfulie.com') #this class includes RequestAdapter module.
-      #   puts @re.as('application/atom+xml').get!('/posts').title #=> 'Hello World!'
-      #
-      module RequestAdapter
-        attr_reader   :host
-        attr_accessor :cookies
-        attr_writer   :default_headers
-
-        def host=(host)
-          if host.is_a?(::URI)
-            @host = host
-          else
-            @host = ::URI.parse(host)
-          end
-        end
-
-        def default_headers
-          @default_headers ||= {}
-        end
-
-        # GET HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def get(path, *args)
-          request(:get, path, *args)
-        end
-
-        # HEAD HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def head(path, *args)
-          request(:head, path, *args)
-        end
-
-        # POST HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def post(path, payload, *args)
-          request(:post, path, payload, *args)
-        end
-
-        # PATCH HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def patch(path, payload, *args)
-          request(:patch, path, payload, *args)
-        end
-
-        # PUT HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def put(path, payload, *args)
-          request(:put, path, payload, *args)
-        end
-
-        # DELETE HTTP verb without {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def delete(path, *args)
-          request(:delete, path, *args)
-        end
-
-        # GET HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def get!(path, *args)
-          request!(:get, path, *args)
-        end
-
-        # HEAD HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def head!(path, *args)
-          request!(:head, path, *args)
-        end
-
-        # POST HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def post!(path, payload, *args)
-          request!(:post, path, payload, *args)
-        end
-
-        # PATCH HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def patch!(path, payload, *args)
-          request!(:patch, path, payload, *args)
-        end
-
-        # PUT HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>payload: 'some text'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def put!(path, payload, *args)
-          request!(:put, path, payload, *args)
-        end
-
-        # DELETE HTTP verb {Error}
-        # * <tt>path: '/posts'</tt>
-        # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def delete!(path, *args)
-          request!(:delete, path, *args)
-        end
-
-        # Executes a request against your server and return a response instance without {Error}
-        # * <tt>method: :get,:post,:delete,:head,:put</tt>
-        # * <tt>path: '/posts'</tt>
-        # * <tt>args: payload: 'some text' and/or headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def request(method, path, *args)
-          request!(method, path, *args) 
-        rescue Error::RESTError => se
-          [[@host, path], nil, se.response]
-        end
-
-        # Executes a request against your server and return a response instance.
-        # * <tt>method: :get,:post,:delete,:head,:put</tt>
-        # * <tt>path: '/posts'</tt>
-        # * <tt>args: payload: 'some text' and/or headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-        def request!(method, path, *args)
-          headers = default_headers.merge(args.extract_options!)
-          unless @host.user.blank? && @host.password.blank?
-            headers["Authorization"] = "Basic " + ["#{@host.user}:#{@host.password}"].pack("m").delete("\r\n")
-          end
-          headers['cookie'] = @cookies if @cookies
-          args << headers
-
-          ::Restfulie::Common::Logger.logger.info(request_to_s(method, path, *args)) if ::Restfulie::Common::Logger.logger
-          begin
-            http_request = get_connection_provider
-            response = Restfulie::Client.cache_provider.get([@host, path], http_request, method)
-            return [[@host, path], http_request, response] if response
-            response = ResponseHandler.handle(method, path, http_request.send(method, path, *args))
-          rescue Exception => e
-            Restfulie::Common::Logger.logger.error(e)
-            raise Error::ServerNotAvailableError.new(self, Response.new(method, path, 503, nil, {}), e )
-          end 
-
-          case response.code
-          when 100..299
-            [[@host, path], http_request, response]
-          when 300..399
-            raise Error::Redirection.new(self, response)
-          when 400
-            raise Error::BadRequest.new(self, response)
-          when 401
-            raise Error::Unauthorized.new(self, response)
-          when 403
-            raise Error::Forbidden.new(self, response)
-          when 404
-            raise Error::NotFound.new(self, response)
-          when 405
-            raise Error::MethodNotAllowed.new(self, response)
-          when 407
-            raise Error::ProxyAuthenticationRequired.new(self, response)
-          when 409
-            raise Error::Conflict.new(self, response)
-          when 410
-            raise Error::Gone.new(self, response)
-          when 412
-            raise Error::PreconditionFailed.new(self, response)
-          when 402, 406, 408, 411, 413..499
-            raise Error::ClientError.new(self, response)
-          when 501
-            raise Error::NotImplemented.new(self, response)
-          when 500, 502..599
-            raise Error::ServerError.new(self, response)
-          else
-            raise Error::UnknownError.new(self, response)
-          end
-        end
-
-        private
-
-        def get_connection_provider
-          @connection ||= ::Net::HTTP.new(@host.host, @host.port)
-        end
-
-        protected
-
-        def request_to_s(method, path, *args)
-          result = ["#{method.to_s.upcase} #{path}"]
-
-          arguments = args.dup
-          headers = arguments.extract_options!
-
-          if [:post, :put].include?(method)
-            body = arguments.shift
-          end
-
-          result << headers.collect { |key, value| "#{key}: #{value}" }.join("\n")
-
-          (result + [body ? (body.inspect + "\n") : nil]).compact.join("\n") << "\n"
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_builder.rb

@@ -1,114 +0,0 @@
-require 'uri'
-
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      # ==== RequestBuilder
-      # Uses RequestAdapater to create a HTTP Request DSL 
-      #
-      # ==== Example:
-      #
-      #   @builder = ::Restfulie::Client::HTTP::RequestBuilderExecutor.new("http://restfulie.com") #this class includes RequestBuilder module.
-      #   @builder.at('/posts').as('application/xml').accepts('application/atom+xml').with('Accept-Language' => 'en').get.code #=> 200
-      #
-      module RequestBuilder
-        include RequestAdapter
-
-        #Set host
-        def at(url)
-          self.host = url
-          self
-        end
-
-        #Set Content-Type and Accept headers
-        def as(content_type)
-          headers['Content-Type'] = content_type
-          accepts(content_type)
-        end
-
-        #Set Accept headers
-        def accepts(content_type)
-          headers['Accept'] = content_type
-          self
-        end
-
-        # Merge internal header
-        #
-        # * <tt>headers (e.g. {'Cache-control' => 'no-cache'})</tt>
-        #
-        def with(headers)
-          self.headers.merge!(headers)
-          self
-        end
-
-        def headers
-          @headers ||= {}
-        end
-
-        # Path (e.g. http://restfulie.com/posts => /posts)
-        def path
-          host.path
-        end
-
-        def get(params = {})
-          request(:get, add_querystring(path, params), headers)
-        end
-
-        def head
-          request(:head, path, headers)
-        end
-
-        def post(payload)
-          request(:post, path, payload, headers)
-        end
-
-        def patch(payload)
-          request(:patch, path, payload, headers)
-        end
-
-        def put(payload)
-          request(:put, path, payload, headers)
-        end
-
-        def delete
-          request(:delete, path, headers)
-        end
-        
-        def get!(params = {})
-          request!(:get, add_querystring(path, params), headers)
-        end
-
-        def head!
-          request!(:head, path, headers)
-        end
-
-        def post!(payload)
-          request!(:post, path, payload, headers)
-        end
-
-        def patch!(payload)
-          request!(:patch, path, payload, headers)
-        end
-
-        def put!(payload)
-          request!(:put, path, payload, headers)
-        end
-
-        def delete!
-          request!(:delete, path, headers)
-        end
-
-        protected
-        
-        def add_querystring(path, params)
-          params = params.map { |param, value| "#{param}=#{value}"}.join("&")
-          params.blank? ? path : URI.escape("#{path}?#{params}")
-        end
-
-        def headers=(h)
-          @headers = h
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_builder_executor.rb

@@ -1,24 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      #=This class includes RequestBuilder module.
-      class RequestBuilderExecutor < RequestExecutor
-        include RequestBuilder
-
-        def host=(host)
-          super
-          at(self.host.path)
-        end
-
-        def at(path)
-          @path = path
-          self
-        end
-
-        def path
-          @path
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_executor.rb

@@ -1,17 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      #=This class includes RequestAdapter module.
-      class RequestExecutor
-        include RequestAdapter
-
-        # * <tt> host (e.g. 'http://restfulie.com') </tt>
-        # * <tt> default_headers  (e.g. {'Cache-control' => 'no-cache'} ) </tt>
-        def initialize(host, default_headers = {})
-          self.host=host
-          self.default_headers=default_headers
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_follow.rb

@@ -1,42 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      # ==== RequestFollow follow new location of a document usually with response codes 201,301,302,303 and 307. You can also configure other codes.
-      # 
-      # ==== Example:
-      # @executor = ::Restfulie::Client::HTTP::RequestFollowExecutor.new("http://restfulie.com") #this class includes RequestFollow module.
-      # @executor.at('/custom/songs').accepts('application/atom+xml').follow(201).post!("custom").code
-      module RequestFollow
-        include RequestBuilder
-  
-        def follow(code = nil)
-          @follow ||= true # turn on follow redirection
-          follow_codes << code unless code.nil? or follow_codes.include?(code)
-          self
-        end
-  
-        def request!(method, path, *args)#:nodoc:
-          begin
-            response = super
-          rescue Error::Redirection => e
-            raise e unless @follow # normal behavior for bang methods is to raise the exception
-            response = e.response
-            if follow_codes.include?(response.code)
-              location = response.headers['location'] || response.headers['Location']
-              raise Error::AutoFollowWithoutLocationError.new(self, response) unless location
-              self.host = location
-              response = super(:get, location, headers)
-            end
-            response
-          end
-        end
-  
-        protected
-  
-          def follow_codes
-            @follow_codes ||= [201,301,302,303,307]        
-          end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_follow_executor.rb

@@ -1,10 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      #=This class inherits RequestBuilderExecutor and include RequestFollow module.
-      class RequestFollowExecutor < RequestBuilderExecutor
-        include RequestFollow
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_history.rb

@@ -1,71 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      # ==== RequestHistory
-      # Uses RequestBuilder and remind previous requests
-      #
-      # ==== Example:
-      #
-      #   @executor = ::Restfulie::Client::HTTP::RequestHistoryExecutor.new("http://restfulie.com") #this class includes RequestHistory module.
-      #   @executor.at('/posts').as('application/xml').accepts('application/atom+xml').with('Accept-Language' => 'en').get.code #=> 200 #first request
-      #   @executor.at('/blogs').as('application/xml').accepts('application/atom+xml').with('Accept-Language' => 'en').get.code #=> 200 #second request
-      #   @executor.request_history!(0) #doing first request
-      #
-      module RequestHistory
-        include RequestBuilder
-
-        def snapshots
-          @snapshots ||= []
-        end
-
-        def max_to_remind
-          10
-        end
-        
-        def request!(method=nil, path=nil, *args)#:nodoc:
-          if method == nil || path == nil 
-            raise 'History not selected' unless @snapshot
-            super( @snapshot[:method], @snapshot[:path], *@snapshot[:args] )
-          else
-            @snapshot = make_snapshot(method, path, *args)
-            unless snapshots.include?(@snapshot)
-              snapshots.shift if snapshots.size >= max_to_remind
-              snapshots << @snapshot
-            end
-            super
-          end
-        end
-
-        def request(method=nil, path=nil, *args)#:nodoc:
-          request!(method, path, *args) 
-        rescue Error::RESTError => se
-          [[@host, path], nil, se.response]
-        end
-
-        def history(number)
-          @snapshot = snapshots[number]
-          raise "Undefined snapshot for #{number}" unless @snapshot
-          self.host    = @snapshot[:host]
-          self.cookies = @snapshot[:cookies]
-          self.headers = @snapshot[:headers]
-          self.default_headers = @snapshot[:default_headers]
-          at(@snapshot[:path])
-        end
-
-        private
-
-        def make_snapshot(method, path, *args)
-          arguments = args.dup
-          cutom_headers = arguments.extract_options!
-          { :host            => self.host.dup,
-            :default_headers => self.default_headers.dup,
-            :headers         => self.headers.dup,
-            :cookies         => self.cookies,
-            :method          => method, 
-            :path            => path,
-            :args            => arguments << self.headers.merge(cutom_headers)   }
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_history_executor.rb

@@ -1,10 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      #=This class inherits RequestFollowExecutor and include RequestHistory module.
-      class RequestHistoryExecutor < RequestBuilderExecutor
-        include RequestHistory
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_marshaller.rb

@@ -1,129 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP
-      module RequestMarshaller
-        include RequestHistory
-        
-        @@representations = {
-          'application/atom+xml' => ::Restfulie::Common::Converter::Atom,
-          'application/xml'      => ::Restfulie::Common::Converter::Xml,
-          'text/xml'             => ::Restfulie::Common::Converter::Xml,
-          'application/json'     => ::Restfulie::Common::Converter::Json
-        }
-        
-        def self.register_representation(media_type,representation)
-          @@representations[media_type] = representation
-        end
-
-        def self.content_type_for(media_type)
-          return nil unless media_type
-          content_type = media_type.split(';')[0] # [/(.*?);/, 1]
-          @@representations[content_type]
-        end
-    
-        def accepts(media_types)
-          @default_representation = @@representations[media_types]
-          super
-        end
-    
-        def raw
-          @raw = true
-          self
-        end
-    
-        def post(payload, options = { :recipe => nil })
-          request(:post, path, payload, options.merge(headers))
-        end
-    
-        def post!(payload, options = { :recipe => nil })
-          request!(:post, path, payload, options.merge(headers))
-        end
-    
-        # Executes super if its a raw request, returning the content itself.
-        # otherwise tries to parse the content with a mediatype handler or returns the response itself.
-        def request!(method, path, *args)      
-          if has_payload?(method, path, *args)
-            recipe = get_recipe(*args)
-            
-            payload = get_payload(method, path, *args)
-            rel = self.respond_to?(:rel) ? self.rel : ""
-            type = headers['Content-Type']
-            raise Restfulie::Common::Error::RestfulieError, "Missing content type related to the data to be submitted" unless type
-            marshaller = RequestMarshaller.content_type_for(type)
-            payload = marshaller.marshal(payload, { :rel => rel, :recipe => recipe }) unless payload.nil? || (payload.kind_of?(String) && payload.empty?)
-            args = set_marshalled_payload(method, path, payload, *args)
-            args = add_representation_headers(method, path, marshaller, *args)
-          end
-    
-          if @acceptable_mediatypes
-            unmarshaller = RequestMarshaller.content_type_for(@acceptable_mediatypes)
-            args = add_representation_headers(method, path, unmarshaller, *args)
-          end
-    
-          key, req, response = super(method, path, *args) 
-          Restfulie::Client.cache_provider.put(key, req, response)
-
-          parse_response(response)
-        end
-    
-        private
-        
-        # parses the http response.
-        # first checks if its a 201, redirecting to the resource location.
-        # otherwise check if its a raw request, returning the content itself.
-        # finally, tries to parse the content with a mediatype handler or returns the response itself.
-        def parse_response(response)
-          if response.code == 201
-            request = Restfulie.at(response.headers['location'])
-            request.accepts(@acceptable_mediatypes) if @acceptable_mediatypes
-            request.get!
-          elsif @raw
-            response
-          elsif !response.body.empty?
-            representation = RequestMarshaller.content_type_for(response.headers['content-type']) || Restfulie::Common::Representation::Generic.new
-            representation.unmarshal(response.body).tap do |u|
-              u.extend(ResponseHolder)
-              u.response = response
-            end
-          else
-            response.tap do |resp|
-              resp.extend(ResponseHolder)
-              resp.response = response
-            end
-          end
-        end
-    
-        def get_recipe(*args)
-          headers_and_recipe = args.extract_options! 
-          recipe = headers_and_recipe.delete(:recipe)
-          args << headers_and_recipe
-          recipe
-        end
-    
-        def has_payload?(method, path, *args)
-          [:put,:post,:patch].include?(method)
-        end
-    
-        def get_payload(method, path, *args)
-          args.extract_options! #remove header
-          args.shift #payload
-        end
-    
-        def set_marshalled_payload(method, path, payload, *args)
-          headers = args.extract_options!
-          args.tap do |a|
-            a.shift #old payload
-            a << payload << headers
-          end
-        end
-    
-        def add_representation_headers(method, path, representation, *args)
-          headers = args.extract_options!
-          headers = headers.merge(representation.headers[method] || {})
-          args << headers
-          args
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/request_marshaller_executor.rb

@@ -1,10 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP
-      #=This class includes RequestBuilder module.
-      class RequestMarshallerExecutor < RequestHistoryExecutor
-        include RequestMarshaller
-      end
-    end
-  end
-end

data/lib/restfulie/client/http/response.rb

@@ -1,23 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP #:nodoc:
-      #=Response
-      # Default response class
-      class Response
-        attr_reader :method
-        attr_reader :path
-        attr_reader :code
-        attr_reader :body
-        attr_reader :headers
-
-        def initialize(method, path, code, body, headers)
-          @method = method
-          @path = path
-          @code = code
-          @body = body 
-          @headers = headers
-        end
-      end
-    end
-  end
-end