restfulie 0.9.3 → 1.0.0.beta1

data/lib/restfulie/client/feature/setup_header.rb

@@ -0,0 +1,22 @@
+module Restfulie::Client::Feature
+
+  class SetupHeader
+    
+    def execute(flow, request, response, env)
+      headers = request.default_headers.dup.merge(request.headers)
+      host = request.host
+      if host.user || host.password
+        headers["Authorization"] = "Basic " + ["#{host.user}:#{host.password}"].pack("m").delete("\r\n")
+      end
+      headers.delete :recipe
+      headers['cookie'] = request.cookies if request.cookies
+      
+      # gs: this should not be overriden, do it in some other way
+      request.headers = headers
+      
+      flow.continue(request, response, env)
+    end
+    
+  end
+  
+end

data/lib/restfulie/client/feature/throw_error.rb

@@ -0,0 +1,41 @@
+class Restfulie::Client::Feature::ThrowError
+  def execute(flow, request, result_so_far, env)
+    result = flow.continue(request, result_so_far, env)
+    if result.kind_of? Exception
+      Restfulie::Common::Logger.logger.error(result)
+      raise Restfulie::Client::HTTP::Error::ServerNotAvailableError.new(request, Restfulie::Client::HTTP::Response.new(request.verb, request.path, 503, nil, {}), result )
+    end
+    case result.response.code.to_i
+    when 100..299
+      result
+    when 300..399
+      raise Restfulie::Client::HTTP::Error::Redirection.new(request, result)
+    when 400
+      raise Restfulie::Client::HTTP::Error::BadRequest.new(request, result)
+    when 401
+      raise Restfulie::Client::HTTP::Error::Unauthorized.new(request, result)
+    when 403
+      raise Restfulie::Client::HTTP::Error::Forbidden.new(request, result)
+    when 404
+      raise Restfulie::Client::HTTP::Error::NotFound.new(request, result)
+    when 405
+      raise Restfulie::Client::HTTP::Error::MethodNotAllowed.new(request, result)
+    when 407
+      raise Restfulie::Client::HTTP::Error::ProxyAuthenticationRequired.new(request, result)
+    when 409
+      raise Restfulie::Client::HTTP::Error::Conflict.new(request, result)
+    when 410
+      raise Restfulie::Client::HTTP::Error::Gone.new(request, result)
+    when 412
+      raise Restfulie::Client::HTTP::Error::PreconditionFailed.new(request, result)
+    when 402, 406, 408, 411, 413..499
+      raise Restfulie::Client::HTTP::Error::ClientError.new(request, result)
+    when 501
+      raise Restfulie::Client::HTTP::Error::NotImplemented.new(request, result)
+    when 500, 502..599
+      raise Restfulie::Client::HTTP::Error::ServerError.new(request, result)
+    else
+      raise Restfulie::Client::HTTP::Error::UnknownError.new(request, result)
+    end
+  end
+end

data/lib/restfulie/client/feature/verb.rb

@@ -0,0 +1,119 @@
+module Restfulie::Client::Feature::Verb
+
+  # GET HTTP verb without {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def get(params = {})
+    @verb = :get
+    at query_string(params)
+    request_flow
+  end
+
+  # HEAD HTTP verb without {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def head
+    @verb = :head
+    request_flow
+  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(payload, options = {:recipe => nil})
+    @verb = :post
+    request_flow :body => payload
+  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(payload)
+    @verb = :patch
+    request_flow :body => payload
+  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(payload)
+    @verb = :put
+    request_flow :body => payload
+  end
+
+  # DELETE HTTP verb without {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def delete
+    @verb = :delete
+    request_flow
+  end
+
+  # GET HTTP verb {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def get!(params = {})
+    @verb = :get
+    at query_string(params)
+    request :throw_error
+    request_flow 
+  end
+
+  # HEAD HTTP verb {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def head!
+    @verb = :head
+    request :throw_error
+    request_flow 
+  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!(payload, options = {:recipe => nil})
+    @verb = :post
+    request :throw_error
+    request_flow :body => payload
+  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!(payload)
+    @verb = :patch
+    request :throw_error
+    request_flow :body => payload
+  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!(payload)
+    @verb = :put
+    request :throw_error
+    request_flow :body => payload
+  end
+
+  # DELETE HTTP verb {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def delete!
+    @verb = :delete
+    request :throw_error
+    request_flow 
+  end
+
+  protected
+
+  def query_string(params)
+    params = params.map { |param, value| "#{param}=#{value}"}.join("&")
+    params.blank? ? "" : URI.escape("?#{params}")
+  end
+end

data/lib/restfulie/client/feature.rb

@@ -0,0 +1,5 @@
+module Restfulie::Client
+  module Feature
+    Dir["#{File.dirname(__FILE__)}/feature/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
+  end
+end

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

@@ -1,9 +1,29 @@
-module Restfulie
-  module Client
-    module HTTP
-      module ResponseHolder
-        attr_accessor :response
-      end
+module Restfulie::Client::HTTP
+  module ResponseHolder
+    attr_reader :response, :request
+    
+    def resource
+      type = headers['content-type'] || response['Content-Type']
+      representation = Restfulie::Common::Converter.content_type_for(type[0]) || Restfulie::Common::Representation::Generic.new
+      representation.unmarshal(response.body)
     end
+    
+    def at(uri)
+      request.clone.at(uri)
+    end
+    
+    def headers
+      response.to_hash
+    end
+    
+    def results_from(request, response)
+      @request = request
+      @response = response
+    end
+
+    def verb
+      @request.verb
+    end
+        
   end
 end

data/lib/restfulie/client/http.rb

@@ -1,27 +1,7 @@
 module Restfulie
   module Client
     module HTTP#:nodoc:
-      autoload :Error, 'restfulie/client/http/error'
-      autoload :Response, 'restfulie/client/http/response'
-      autoload :ResponseHandler, 'restfulie/client/http/response_handler'
-      autoload :RequestAdapter, 'restfulie/client/http/request_adapter'
-      autoload :RequestBuilder, 'restfulie/client/http/request_builder'
-      autoload :RequestFollow, 'restfulie/client/http/request_follow'
-      autoload :RequestHistory, 'restfulie/client/http/request_history'
-      autoload :RequestExecutor, 'restfulie/client/http/request_executor'
-      autoload :RequestBuilderExecutor, 'restfulie/client/http/request_builder_executor'
-      autoload :RequestFollowExecutor, 'restfulie/client/http/request_follow_executor'
-      autoload :RequestHistoryExecutor, 'restfulie/client/http/request_history_executor'
-      autoload :Cache, 'restfulie/client/http/cache'
-      autoload :ResponseHolder, 'restfulie/client/http/response_holder'
-      autoload :RequestMarshaller, 'restfulie/client/http/request_marshaller'
-      autoload :LinkRequestBuilder, 'restfulie/client/http/link_request_builder'
-      autoload :RequestMarshallerExecutor, 'restfulie/client/http/request_marshaller_executor'
+      Dir["#{File.dirname(__FILE__)}/http/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
     end
   end
 end
-
-require 'restfulie/client/ext/atom_ext'
-require 'restfulie/client/ext/xml_ext'
-require 'restfulie/client/ext/http_ext'
-require 'restfulie/client/ext/json_ext'

data/lib/restfulie/client/master_delegator.rb

@@ -0,0 +1,31 @@
+class MasterDelegator
+
+  alias_method :original_respond_to?, :respond_to?
+
+  def respond_to?(sym)
+    original_respond_to?(sym) || @requester.respond_to?(sym)
+  end
+
+  def method_missing(sym, *args, &block)
+    if original_respond_to?(sym)
+      result = super(sym, *args, &block)
+    elsif @requester.respond_to?(sym)
+      result = @requester.send(sym, *args, &block)
+    else
+      # let it go
+      return super(sym, *args, &block)
+    end
+    delegate_parse result
+  end
+  
+  protected
+  
+  def delegate(what, *args, &block)
+    delegate_parse @requester.send(what, *args, &block)
+  end
+  
+  def delegate_parse(result)
+    (result == @requester) ? self : result
+  end
+  
+end

data/lib/restfulie/client/mikyung/core.rb

@@ -42,6 +42,11 @@ module Restfulie
       
         # keeps changing from a steady state to another until its goal has been achieved
         def run
+
+          # load the steps and scenario
+          @goal.steps 
+          @goal.scenario 
+
           if @start.kind_of? String
             client = Restfulie.at(@start)
             client = client.follow if @follow
@@ -52,10 +57,6 @@ module Restfulie
             @start = current = @goal.class.get_restfulie.get
           end
           
-          # load the steps and scenario
-          @goal.steps 
-          @goal.scenario 
-          
           while(!@goal.completed?(current))
             current = @walker.move(@goal, current, self)
           end

data/lib/restfulie/client/mikyung/steady_state_walker.rb

@@ -14,7 +14,7 @@ module Restfulie
         private
         
           def try_to_execute(step, current, max_attempts, mikyung)
-            raise "Unable to proceed when trying to #{step}" if max_attempts == 0
+            raise "Unable to proceed when trying to analyze #{step.body}" if max_attempts == 0
         
             resource = step
             raise "Step returned 'give up'" if resource.nil?

data/lib/restfulie/client/mikyung.rb

@@ -1,13 +1,7 @@
 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'
+      Dir["#{File.dirname(__FILE__)}/mikyung/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
     end
   end
 end
@@ -17,6 +11,5 @@ end
 module Restfulie
   class Mikyung < Restfulie::Client::Mikyung::Core
     Restfulie::Common::Logger.logger.level = Logger::INFO
-    # empty class
   end
 end

data/lib/restfulie/client.rb

@@ -2,12 +2,15 @@ require 'restfulie/common'
 
 module Restfulie
   module Client
+    autoload :MasterDelegator, 'restfulie/client/master_delegator'
     autoload :HTTP, 'restfulie/client/http'
     autoload :Configuration, 'restfulie/client/configuration'
     autoload :EntryPoint, 'restfulie/client/entry_point'
     autoload :Base, 'restfulie/client/base'
     autoload :Mikyung, 'restfulie/client/mikyung'
     autoload :Cache, 'restfulie/client/cache'
+    autoload :Feature, 'restfulie/client/feature'
+    autoload :Dsl, 'restfulie/client/dsl'
     
     mattr_accessor :cache_provider, :cache_store
 
@@ -20,5 +23,4 @@ end
 require 'restfulie/client/ext/http_ext'
 require 'restfulie/client/ext/atom_ext'
 require 'restfulie/client/ext/json_ext'
-require 'restfulie/client/ext/xml_ext'
 

data/lib/restfulie/common/converter/atom/base.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/conversions'
+
 module Restfulie
   module Common
     module Converter

data/lib/restfulie/common/converter/form_url_encoded.rb

@@ -0,0 +1,16 @@
+class Restfulie::Common::Converter::FormUrlEncoded < Restfulie::Common::Representation::Generic
+  def self.marshal(content, rel)
+      if content.kind_of? Hash
+        content.map { |key, value| "#{key}=#{value}" }.join("&")
+      else
+        content
+      end
+  end
+  
+  def self.unmarshal(content)
+  	def content.links
+      []
+    end
+    content
+  end
+end

data/lib/restfulie/common/converter/json/base.rb

@@ -34,8 +34,11 @@ module Restfulie
               
               # Check if the object is already an json
               unless recipe
-                return Restfulie::Common::Representation::Json.create(obj) if obj.kind_of?(Hash) || obj.kind_of?(Array)
-                raise Restfulie::Common::Error::ConverterError.new("Recipe required")
+                if obj.kind_of?(Hash) || obj.kind_of?(Array)
+                  return Restfulie::Common::Representation::Json.create(obj)
+                else
+                  raise Restfulie::Common::Error::ConverterError.new("Recipe required")
+                end
               end
                       
               # Get recipe already described

data/lib/restfulie/common/converter/open_search/descriptor.rb

@@ -0,0 +1,32 @@
+class Restfulie::Common::Converter::OpenSearch::Descriptor
+  
+  def initialize(hash)
+    @hash = hash["OpenSearchDescription"]
+  end
+  
+  def urls
+    uris = @hash["Url"]
+    uris.kind_of?(Array) ? uris : [uris]
+  end
+  
+  def use(content_type)
+    uri = urls.find do |url|
+      url["type"]==content_type
+    end
+    return nil if uri.nil?
+    
+    base_uri, params_pattern = extract_uri(uri)
+    Restfulie.at(base_uri).accepts(content_type).open_search.with_pattern(params_pattern)
+  end
+  
+  private
+  def extract_uri(uri)
+    uri = uri["template"]
+    interrogation = uri.index("?")
+    params = uri[interrogation+1..uri.size]
+    base_uri = uri[0..interrogation-1]
+    [base_uri, params]
+  end
+  
+end
+

data/lib/restfulie/common/converter/open_search.rb

@@ -0,0 +1,16 @@
+module Restfulie
+  module Common
+    class Converter::OpenSearch#:nodoc:
+      autoload :Descriptor, 'restfulie/common/converter/open_search/descriptor'
+    end
+  end
+end
+
+class Restfulie::Common::Converter::OpenSearch
+  
+  def self.unmarshal(xml)
+    hash = Hash.from_xml(xml)
+    descriptor = Descriptor.new(hash)
+  end
+  
+end

data/lib/restfulie/common/converter/xml/base.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/conversions'
+
 module Restfulie
   module Common
     module Converter
@@ -43,7 +45,7 @@ module Restfulie
               end
               
               # Create representation and proxy
-              builder = Builder.new(obj)
+              builder = Builder.new(obj, options)
         
               # Check recipe arity size before calling it
               recipe.call(*[builder, obj, options][0,recipe.arity])

data/lib/restfulie/common/converter/xml/builder.rb

@@ -42,11 +42,12 @@ module Restfulie
             insert_value("link", nil, options)
           end
           
-          def members(a_collection = nil, &block)
+          def members(a_collection = nil, options = {}, &block)
             collection = a_collection || @obj 
             raise Error::BuilderError("Members method require a collection to execute") unless collection.respond_to?(:each)
             collection.each do |member|
-              entry = @doc.create_element(Restfulie::Common::Converter.root_element_for(member))
+              root = options[:root] || Restfulie::Common::Converter.root_element_for(member)
+              entry = @doc.create_element(root)
               entry.parent = @parent
               @parent = entry
               block.call(self, member)

data/lib/restfulie/common/converter/xml/helpers.rb

@@ -3,12 +3,12 @@ module Restfulie
     module Converter
       module Xml
         module Helpers
-          def collection(obj, *args, &block)
-            Xml.to_xml(obj, {}, &block)
+          def collection(obj, opts = {}, &block)
+            Xml.to_xml(obj, opts, &block)
           end
         
-          def member(obj, *args, &block)
-            Xml.to_xml(obj, {}, &block)
+          def member(obj, opts = {}, &block)
+            Xml.to_xml(obj, opts, &block)
           end
         end
       end

data/lib/restfulie/common/converter/xml/link.rb

@@ -18,6 +18,11 @@ module Restfulie
           def type
             content_type
           end
+          def follow
+            r = Restfulie.at(href)
+            r = r.as(content_type) if content_type
+            r
+          end
         end
       end
     end

data/lib/restfulie/common/converter/xml/links.rb

@@ -6,11 +6,7 @@ module Restfulie
           def initialize(links)
             links = [links] unless links.kind_of? Array
             links = [] unless links
-            @links = links.map do |l|
-              link = Restfulie::Common::Converter::Xml::Link.new(l)
-              link.instance_eval { self.class.send :include, ::Restfulie::Client::HTTP::LinkRequestBuilder }
-              link
-            end
+            @links = links.map { |l| Restfulie::Common::Converter::Xml::Link.new(l) }
           end
           
           def method_missing(sym, *args)

data/lib/restfulie/common/converter.rb

@@ -1,10 +1,7 @@
 module Restfulie
   module Common
     module Converter
-      autoload :Values, 'restfulie/common/converter/values'
-      autoload :Atom, 'restfulie/common/converter/atom'
-      autoload :Json, 'restfulie/common/converter/json'
-      autoload :Xml, 'restfulie/common/converter/xml'
+      Dir["#{File.dirname(__FILE__)}/converter/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
 
       # Returns the default root element name for an item or collection
       def self.root_element_for(obj)
@@ -16,6 +13,30 @@ module Restfulie
           obj.class.to_s.underscore
         end
       end
+      
+      def self.register(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
+      
+      private
+      
+      def self.representations
+        @representations ||= {}
+      end
+      
+      register 'application/atom+xml' , ::Restfulie::Common::Converter::Atom
+      register 'application/xml' , ::Restfulie::Common::Converter::Xml
+      register 'text/xml' , ::Restfulie::Common::Converter::Xml
+      register 'application/json' , ::Restfulie::Common::Converter::Json
+      register 'application/opensearchdescription+xml' , ::Restfulie::Common::Converter::OpenSearch
+      register 'application/x-www-form-urlencoded', Restfulie::Common::Converter::FormUrlEncoded
+      
     end
   end
 end

data/lib/restfulie/common/core_ext/hash.rb

@@ -1,12 +1,18 @@
 class Hash
+
   def links(*args)
     links = fetch("link", [])
     Restfulie::Common::Converter::Xml::Links.new(links)
   end
+
+  include Restfulie::Common::Links
+
   def method_missing(sym, *args)
     self[sym.to_s].nil? ? super(sym, args) : self[sym.to_s]
   end
+  
   def respond_to?(sym)
     include?(sym.to_s) || super(sym)
   end
+  
 end

data/lib/restfulie/common/links.rb

@@ -0,0 +1,9 @@
+module Restfulie
+  module Common
+    module Links
+      def refresh
+        links.self.follow.get
+      end
+    end
+  end
+end