restfulie 0.1.0.beta1

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

@@ -0,0 +1,32 @@
+class Restfulie::Client::Feature::SerializeBody
+  
+  def execute(flow, request, response, env)
+    
+    if should_have_payload?(request.verb)
+      
+      payload = env[:body]
+      if payload && !(payload.kind_of?(String) && payload.empty?)
+        type = request.headers['Content-Type']
+        raise Restfulie::Common::Error::RestfulieError, "Missing content type related to the data to be submitted" unless type
+      
+        marshaller = Restfulie::Common::Converter.content_type_for(type)
+        raise Restfulie::Common::Error::RestfulieError, "Missing content type for #{type} related to the data to be submitted" unless marshaller
+
+        rel = request.respond_to?(:rel) ? request.rel : ""
+        env[:body] = marshaller.marshal(payload, { :rel => rel, :recipe => env[:recipe] })
+      end
+      
+    end
+
+    flow.continue(request, response, env)
+  end
+  
+  protected
+  
+  PAYLOAD_METHODS = {:put=>true,:post=>true,:patch=>true}
+  
+  def should_have_payload?(method)
+    PAYLOAD_METHODS[method]
+  end
+  
+end

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/cache.rb

@@ -0,0 +1,28 @@
+module Restfulie
+  module Client
+    module HTTP
+      module Cache
+        def store
+          @store || @store = ::ActiveSupport::Cache::MemoryStore.new
+        end
+    
+        def get
+          store.fetch(@uri) do
+            request(:get, @uri, @headers)
+          end
+        end
+    
+        def head
+          store.fetch(@uri) do
+            request(:head, @uri, @headers)
+          end
+        end
+      end
+    
+      class RequestBuilderExecutorWithCache < RequestBuilderExecutor
+        include Cache
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,77 @@
+module Restfulie
+  module Client
+    module HTTP#:nodoc:
+      #Client errors
+      module Error
+      # Standard error thrown on major client exceptions
+        class RESTError < StandardError
+          attr_reader :response
+          attr_reader :request
+  
+          def initialize(request, response)
+            @request  = request
+            @response = response
+          end
+  
+          def to_s
+            "HTTP error #{@response.code} when invoking #{@request.host} via #{@response.method}. " +
+              ((@response.body.blank?) ? "No additional data was sent." : "The complete response was:\n" + @response.body)
+          rescue
+            super
+          end
+        end
+  
+        class AutoFollowWithoutLocationError < RESTError; end
+        
+        # Represents the HTTP code 503
+        class ServerNotAvailableError < RESTError
+          def initialize(request, response, exception)
+            super(request, response)
+            set_backtrace(exception.backtrace)
+          end
+        end
+  
+        class UnknownError < RESTError;  end
+  
+        # Represents the HTTP code 300 range
+        class Redirection < RESTError; end 
+  
+        class ClientError < RESTError; end
+  
+        # Represents the HTTP code 400
+        class BadRequest < ClientError; end 
+  
+        # Represents the HTTP code 401
+        class Unauthorized < ClientError; end 
+  
+        # Represents the HTTP code 403
+        class Forbidden < ClientError; end 
+  
+        # Represents the HTTP code 404
+        class NotFound < ClientError; end 
+  
+        # Represents the HTTP code 405
+        class MethodNotAllowed < ClientError; end 
+  
+        # Represents the HTTP code 412
+        class PreconditionFailed < ClientError; end 
+  
+        # Represents the HTTP code 407
+        class ProxyAuthenticationRequired < ClientError; end 
+  
+        # Represents the HTTP code 409
+        class Conflict < ClientError; end 
+  
+        # Represents the HTTP code 410
+        class Gone < ClientError; end 
+  
+        # Represents the HTTP code 500
+        class ServerError < RESTError; end 
+  
+        # Represents the HTTP code 501
+        class NotImplemented < ServerError; end 
+      end
+    end
+  end
+end
+

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

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

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

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/concatenator.rb

@@ -0,0 +1,18 @@
+module Restfulie
+  module Client
+    module Mikyung
+      # Concatenates pure text in order to build messages
+      # that are used as patterns.
+      # Usage:
+      # When there is a machine
+      #
+      # Will invoke concatenate 'machine' with 'a' with 'is' with 'there'
+      class Concatenator
+        attr_reader :content
+        def initialize(content, *args)
+          @content = args.inject(content) { |buf, arg| buf << " " << arg.content }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Restfulie
+  module Client
+    module Mikyung
+      # iterates following a series of steps provided a goal and a starting uri.
+      #
+      # Restfulie::Client::Mikyung.achieve(objective).at(uri).run
+      #
+      # In order to implement your own walker, supply an object that respond to the move method.
+      # Check the run method code.
+      class Core
+        attr_reader :start, :goal, :walker, :accepts, :follow
+        
+        def initialize
+          @walker = Restfulie::Client::Mikyung::SteadyStateWalker.new
+        end
+        
+        def walks_with(walker)
+          @walker = walker
+          self
+        end
+      
+        # initializes with a goal in mind
+        def achieve(goal)
+          @goal = goal
+          self
+        end
+        
+        def at(start)
+          @start = start
+          self
+        end
+
+        def follow
+          @follow = true
+          self
+        end
+
+        def accepts(accepts)
+          @accepts = accepts
+          self
+        end
+      
+        # keeps changing from a steady state to another until its goal has been achieved
+        def run
+          if @start.kind_of? String
+            client = Restfulie.at(@start)
+            client = client.follow if @follow
+            client = client.accepts(@accepts) if @accepts
+            @start = current = client.get
+          else
+            # probably configured thru the Rest Process Model class
+            @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
+          current
+        end
+      end
+    end
+
+    class UnableToAchieveGoalError < Restfulie::Common::Error::RestfulieError
+    end
+  end
+end

data/lib/restfulie/client/mikyung/languages/german.rb

@@ -0,0 +1,24 @@
+module Restfulie
+  module Client
+    module Mikyung
+      module Languages
+        module German
+          def Wenn(concat, &block)
+            When(concat, &block)
+          end
+          def Und(concat, &block)
+            And(concat, &block)
+          end
+          def Aber(concat, &block)
+            But(concat, &block)
+          end
+          def Dann(concat, &block)
+            Then(concat, &block)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/restfulie/client/mikyung/languages/portuguese.rb

@@ -0,0 +1,23 @@
+module Restfulie
+  module Client
+    module Mikyung
+      module Languages
+        module Portuguese
+          def Quando(concat, &block)
+            When(concat, &block)
+          end
+          def E(concat, &block)
+            And(concat, &block)
+          end
+          def Mas(concat, &block)
+            But(concat, &block)
+          end
+          def Entao(concat, &block)
+            Then(concat, &block)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,11 @@
+module Restfulie
+  module Client
+    module Mikyung
+      module Languages
+        autoload :German, 'restfulie/client/mikyung/german'
+        autoload :Portuguese, 'restfulie/client/mikyung/portuguese'
+      end
+    end
+  end
+end
+