restfulie 0.8.0 → 0.8.1

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,69 @@
+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
+
+        attr_accessor_with_default :max_to_remind, 10
+
+        def snapshots
+          @snapshots ||= []
+        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
+          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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,127 @@
+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
+    
+          response = super(method, path, *args) 
+          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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,23 @@
+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

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

@@ -0,0 +1,67 @@
+module Restfulie
+  module Client
+    module HTTP #:nodoc:
+      #=ResponseHandler
+      # You can change instance registering a class according to the code.
+      #
+      #==Example
+      #
+      #   class RequestExecutor
+      #     include RequestAdapter
+      #     def initialize(host)
+      #       self.host=host
+      #     end
+      #   end
+      #
+      #   class FakeResponse < Restfulie::Client::HTTP::Response
+      #   end
+      #
+      #   Restfulie::Client::HTTP::ResponseHandler.register(201,FakeResponse)  
+      #   @re = Restfulie::Client::HTTP::RequestExecutor.new('http://restfulie.com')
+      #   puts @re.as('application/atom+xml').get!('/posts').class.to_i #=> FakeResponse
+      #
+      module ResponseHandler
+        @@response_handlers = {}
+        ## 
+        # :singleton-method:
+        # Response handlers attribute reader
+        # * code: HTTP status code
+        def self.handlers(code)
+          @@response_handlers[code] 
+        end
+
+        ## 
+        # :singleton-method:
+        # Use to register response handlers
+        #
+        # * <tt>code: HTTP status code</tt>
+        # * <tt>response_class: Response class</tt>
+        #
+        #==Example:
+        #   class FakeResponse < ::Restfulie::Client::HTTP::Response
+        #   end
+        #
+        #   Restfulie::Client::HTTP::ResponseHandler.register(200,FakeResponse)  
+        #
+        def self.register(code,response_class)
+          @@response_handlers[code] = response_class 
+        end
+
+        ## 
+        # :singleton-method:
+        # Request Adapter uses this method to choose response instance
+        #
+        # *<tt>method: :get,:post,:delete,:head,:put</tt>
+        # *<tt>path: '/posts'</tt>
+        # *<tt>http_response</tt>
+        #
+        def self.handle(method, path, http_response)
+          response_class = @@response_handlers[http_response.code.to_i] || Response
+          headers = {}
+          http_response.header.each { |k, v| headers[k] = v }
+          response_class.new( method, path, http_response.code.to_i, http_response.body, headers)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Restfulie
+  module Client
+    module HTTP
+      module ResponseHolder
+        attr_accessor :response
+      end
+    end
+  end
+end

data/lib/restfulie/client/mikyung.rb

@@ -1,19 +1,22 @@
-module Restfulie::Client::Mikyung
-end
-
-%w(
-  when_condition
-  then_condition
-  rest_process_model
-  concatenator
-  core
-  steady_state_walker
-  languages
-).each do |file|
-  require "restfulie/client/mikyung/#{file}"
+module Restfulie
+  module Client
+    module Mikyung
+      autoload :WhenCondition, 'restfulie/client/mikyung/when_condition'
+      autoload :ThenCondition, 'restfulie/client/mikyung/then_condition'
+      autoload :RestProcessModel, 'restfulie/client/mikyung/rest_process_model'
+      autoload :Concatenator, 'restfulie/client/mikyung/concatenator'
+      autoload :Core, 'restfulie/client/mikyung/core'
+      autoload :SteadyStateWalker, 'restfulie/client/mikyung/steady_state_walker'
+      autoload :Languages, 'restfulie/client/mikyung/languages'
+    end
+  end
 end
 
 # Restfulie::Mikyung entry point is based on its core
 # implementation.
-class Restfulie::Mikyung < Restfulie::Client::Mikyung::Core
+module Restfulie
+  class Mikyung < Restfulie::Client::Mikyung::Core
+    Restfulie::Common::Logger.logger.level = Logger::INFO
+    # empty class
+  end
 end