restfulie-nosqlite 1.0.3

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

@@ -0,0 +1,59 @@
+# ==== FollowLink 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::FollowLinkExecutor.new("http://restfulie.com") #this class includes FollowLink module.
+# @executor.at('/custom/songs').accepts('application/atom+xml').follow(201).post!("custom").code
+class Restfulie::Client::Feature::FollowRequest
+  
+  def follow(code = nil)
+    unless code.nil? or follow_codes.include?(code)
+      follow_codes << code
+    end
+    self
+  end
+
+  def execute(flow, request, env)
+    resp = flow.continue(request, env)
+    if !resp.respond_to?(:code)
+      return resp
+    end
+    
+    if should_follow?(resp)
+      follow_this resp, request
+    else
+      resp
+    end
+  end
+
+  protected
+  
+  def should_follow?(response)
+    code = response.code.to_i
+    if code==201 && !response.body.empty?
+      false
+    else
+      follow_codes.include?(code)
+    end
+  end
+  
+  def follow_this(response, request)
+    location = extract_location(response)
+    req = Restfulie.at(location)
+    if accept = request.headers['Accept']
+      req.accepts(accept)
+    end
+    req.get
+  end
+
+  def extract_location(response)
+    location = response.response.headers['location'] || response.response.headers['Location']
+    if location.nil?
+      raise Restfulie::Client::HTTP::Error::AutoFollowWithoutLocationError.new(request, response)
+    end
+    location.first
+  end
+  
+    def follow_codes
+      @follow_codes ||= [201,301,302,303,307]        
+    end
+end

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

@@ -0,0 +1,26 @@
+module Restfulie::Client::Feature::History
+
+  def snapshots
+    @snapshots ||= []
+  end
+
+  def max_to_remind
+    10
+  end
+
+  def history(number)
+    snapshots[snapshots.size + number] || raise("Undefined snapshot for #{number}, only containing #{@snapshots.size} snapshots.")
+  end
+
+  def make_snapshot(request)
+    snapshots.shift if snapshot_full?
+    snapshots << request
+  end
+  
+  private
+
+  def snapshot_full?
+    snapshots.size >= max_to_remind
+  end
+
+end

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

@@ -0,0 +1,17 @@
+# ==== RequestHistory
+# Uses RequestHistory to remind previous requests
+#
+# ==== Example:
+#
+#   result = Restfulie.at(uri).get
+#   result = result.headers.links.payment.get
+#   result.request_history(1) # doing first request
+class Restfulie::Client::Feature::HistoryRequest
+
+  def execute(flow, request, env)
+    resp = flow.continue(request, env)
+    request.make_snapshot(request)
+    resp
+  end
+  
+end

data/lib/restfulie/client/feature/open_search/pattern_matcher.rb

@@ -0,0 +1,25 @@
+module Restfulie::Client::Feature::OpenSearch
+  
+  class PatternMatcher
+
+    def match(params, pattern)
+      params = params.collect do |key, value|
+        [key, value]
+      end
+      pattern = params.inject(pattern) do |pattern, p|
+        what = "{#{p[0]}}"
+        if pattern[what]
+          pattern[what]= "#{p[1]}"
+        end
+        what = "{#{p[0]}?}"
+        if pattern[what]
+          pattern[what]= "#{p[1]}"
+        end
+        pattern
+      end
+      pattern.gsub(/\{[^\?]*\?\}/,"")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,21 @@
+module Restfulie::Client::Feature
+  module OpenSearch
+    autoload :PatternMatcher, 'restfulie/client/feature/open_search/pattern_matcher'
+  end
+end
+
+module Restfulie::Client::Feature::OpenSearch
+  
+  def search(params)
+    at ("?" + PatternMatcher.new.match(params, params_pattern))
+    get
+  end
+  
+  attr_reader :params_pattern
+
+  def with_pattern(params_pattern)
+    @params_pattern = params_pattern
+    self
+  end
+
+end

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

@@ -0,0 +1,13 @@
+# Simple feature that returns the exception in case it occurs.
+# This feature is automatically loaded in the stack.
+class Restfulie::Client::Feature::RescueException
+  
+  def execute(flow, request, env)
+    begin
+      flow.continue(request, env)
+    rescue Exception => e
+      e
+    end
+  end
+  
+end

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

@@ -0,0 +1,25 @@
+# Adds support to retrying a request if the result is 503.
+#
+# To use it, load it in your dsl:
+# Restfulie.at("http://localhost:3000/product/2").retry_when_unavailable.get
+module Restfulie::Client::Feature
+  class RetryWhenUnavailable
+
+  	def execute(chain, request, env)
+  		resp = chain.continue(request, env)
+  		if should_retry?(resp, env)
+  			resp = chain.continue(request, env)
+  		end
+  		resp
+  	end
+  	
+  	protected 
+    # extension point that allows you to redefine
+    # when a request should be retried
+    def should_retry?(response, env)
+      response.code == 503
+    end
+  	
+  end
+end
+

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

@@ -0,0 +1,35 @@
+# Feature responsible for marshalling the entity into the request body.
+# It will use the request content type header to select the proper marshaller using Medie.
+class Restfulie::Client::Feature::SerializeBody
+  
+  def execute(flow, request, env = {})
+    
+    if should_have_payload?(request.verb)
+      
+      env = env.dup
+      payload = env[: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 = Medie.registry.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, 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, 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, env)
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,46 @@
+# Adds support to throwing an error when 300+ response codes are returned
+#
+# To use it, load it in your dsl:
+# Restfulie.at("http://localhost:3000/product/2").throw_error.get
+class Restfulie::Client::Feature::ThrowErrorRequest
+  def execute(flow, request, env)
+    result = flow.continue(request, env)
+    if result.kind_of? Exception
+      Restfulie::Common::Logger.logger.error(result)
+      response = Restfulie::Client::Feature::FakeResponse.new(503, "")
+      raise Restfulie::Client::HTTP::Error::ServerNotAvailableError.new(request, response, result )
+    end
+    case result.response.code
+    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,112 @@
+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 = {})
+    request :throw_error_request
+    get params
+  end
+
+  # HEAD HTTP verb {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def head!
+    request :throw_error_request
+    head
+  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})
+    request :throw_error_request
+    post 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)
+    request :throw_error_request
+    patch 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)
+    request :throw_error_request
+    put payload
+  end
+
+  # DELETE HTTP verb {Error}
+  # * <tt>path: '/posts'</tt>
+  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
+  def delete!
+    request :throw_error_request
+    delete
+  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/link_header.rb

@@ -0,0 +1,39 @@
+module Restfulie::Client::HTTP
+  
+  # Adds support to extracting and navigating through a link in the representation header.
+  module LinkHeader
+    
+    def links
+      r = link_header_to_array
+      Medie::Xml::Links.new(r)
+    end
+    
+    def link(rel)
+      links[rel]
+    end
+        
+    private
+
+    def link_header_to_array
+      links = self["link"][0].split(",")
+      links.map do |link|
+        string_to_hash(link)
+      end
+    end
+
+    def string_to_hash(l)
+      c = l[/<[^>]*/]
+      uri = c[1..c.size]
+      rest = l[/;.*/]
+      rel = extract(rest, "rel")
+      type = extract(rest, "type")
+      { "href" => uri, "rel" => rel, "type" => type }
+    end
+    
+    def extract(from, what)
+      found = Regexp.new("#{what}=\"([^\"]*)\"").match(from)
+      found ? found[1] : nil
+    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 = Medie.registry.for(type[0])
+      representation.unmarshal(response.body)
+    end
+    
+    def at(uri)
+      request.clone.at(uri)
+    end
+    
+    def headers
+      response.to_hash.extend(::Restfulie::Client::HTTP::LinkHeader)
+    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