restfulie-nosqlite 1.0.3

data/lib/restfulie/client/cache/basic.rb

@@ -0,0 +1,78 @@
+# Basic cache implementation for restfulie.
+#
+# It uses the request headers and uri to store it in memory.
+# This cache might not be optimal for long running clients, which should use a memcached based one.
+# Use Restfulie::Client.cache_provider to change the provider
+module Restfulie::Client::Cache
+  class Basic
+
+    def put(key, req, response)
+      if Restfulie::Client::Cache::Restrictions.may_cache?(response)
+        Restfulie::Common::Logger.logger.debug "caching #{key} #{response}"
+        cache_add(key, req, response)
+      end
+      response
+    end
+
+    def get(key, request)
+
+      response = cache_get(key, request)
+      return nil if response.nil?
+
+      if response.has_expired_cache?
+        remove(key)
+      else
+        Restfulie::Common::Logger.logger.debug "RETURNING cache #{key}"
+        cache_hit response
+      end
+
+    end
+    
+    # removes all elements from the cache
+    def clear
+      cache.clear
+    end
+
+  protected
+  
+    # allows you to redefine the cache store
+    def cache
+      Restfulie::Client.cache_store
+    end
+
+  private
+
+    # allows response enhancement when the cache was hit with it
+    def cache_hit(response)
+      response
+    end
+
+    def cache_add(key, req, response)
+      values = (cache.read(key) || []).dup
+      values << [req, response]
+      cache.write(key, values)
+    end
+
+    def cache_get(key, req)
+      return nil unless cache.exist?(key)
+      found = cache.read(key).find do |cached|
+        old_req = cached.first
+        old_response = cached.last
+        
+        headers_match = old_response.vary_headers_for(old_req) == old_response.vary_headers_for(req)
+        if headers_match && old_response.verb == req.verb
+          old_response
+        else
+          false
+        end
+      end
+      found ? found.last : nil
+    end
+
+    def remove(key)
+      cache.delete(key)
+      nil
+    end
+
+  end
+end

data/lib/restfulie/client/cache/fake.rb

@@ -0,0 +1,15 @@
+# Fake cache that does not cache anything
+# Use Restfulie::Client.cache_provider = Restfulie::Client::Cache::Fake.new
+module Restfulie::Client::Cache
+  class Fake
+    def put(url, req, response)
+      response
+    end
+
+    def get(url, req)
+    end
+
+    def clear
+    end
+  end
+end

data/lib/restfulie/client/cache/http_ext.rb

@@ -0,0 +1,123 @@
+require 'time'
+
+# an extesion to http responses
+module Restfulie::Client::HTTP::ResponseStatus
+  
+  attr_accessor :previous
+        
+  # determines if this response code was successful (according to http specs: 200~299)
+  def is_successful?
+    code.to_i >= 200 && code.to_i <= 299
+  end
+    
+  # determines if this response code was successful (according to http specs: 100~199)
+  def is_informational?
+    code.to_i >= 100 && code.to_i <= 199
+  end
+    
+  # determines if this response code was successful (according to http specs: 300~399)
+  def is_redirection?
+    code.to_i >= 300 && code.to_i <= 399
+  end
+    
+  # determines if this response code was successful (according to http specs: 400~499)
+  def is_client_error?
+    code.to_i >= 400 && code.to_i <= 499
+  end
+    
+  # determines if this response code was successful (according to http specs: 500~599)
+  def is_server_error?
+    code.to_i >= 500 && code.to_i <= 599
+  end
+  
+  def etag
+    self['Etag']
+  end
+
+  def last_modified
+    self['Last-Modified']
+  end
+  
+end
+  
+module Restfulie::Client::HTTP::ResponseCacheCheck
+
+  def cache_max_age
+    val = header_value_from('cache-control', /^\s*max-age=(\d+)/)
+    if val
+      val.to_i
+    else
+      0
+    end
+  end
+  
+  def header_value_from(header, expression)
+    h = value_for(headers[header], expression)
+    return nil if h.nil?
+    h.match(expression)[1]
+  end
+  
+  def has_expired_cache?
+    return true if headers['date'].nil?
+    max_time = Time.rfc2822(headers['date'][0]) + cache_max_age.seconds
+    Time.now > max_time
+  end
+
+  # checks if the header's max-age is available and no no-store if available.
+  def may_cache?
+    may_cache_method? && may_cache_field?(headers['cache-control'])
+  end
+  
+  # Returns whether this cache control field allows caching
+  #
+  # may_cache_field(['max-age=2000', 'no-store']) == false
+  # may_cache_field('max-age=2000,no-store') == false
+  # may_cache_field('max-age=2000') == true
+  def may_cache_field?(field)
+    return false if field.nil?
+    
+    if field.kind_of? Array
+      field.each do |f|
+        return false if !may_cache_field?(f)
+      end
+      return true
+    end
+
+    max_age_header = value_for(field, /^max-age=(\d+)/)
+    return false if max_age_header.nil?
+    
+    return !value_for(field, /^no-store/)
+  end
+
+  # extracts the header value for an specific expression, which can be located at the start or in the middle
+  # of the expression
+  def value_for(value, expression)
+    value = value[0] if value.kind_of? Array
+    value.split(",").find { |obj| obj.strip =~ expression }
+  end
+  
+  # extracts all header values related to the Vary header from this response, in order
+  # to implement Vary support from the HTTP Specification
+  # 
+  # example
+  # if the response Vary header is 'Accept','Accept-Language', we have
+  # vary_headers_for({'Accept'=>'application/xml', 'Date' =>'...', 'Accept-Language'=>'de'}) == ['application/xml', 'de']
+  # vary_headers_for({'Date' => '...', 'Accept-Language'=>'de'}) == [nil, 'de']
+  def vary_headers_for(request)
+    return nil if headers['vary'].nil?
+    headers['vary'].split(',').map do |key|
+      request[key.strip]
+    end
+  end
+    
+  private
+  def may_cache_method?
+    verb == :get || verb == :post
+  end
+end
+
+class Net::HTTPResponse
+  include Restfulie::Client::HTTP::ResponseStatus
+  include Restfulie::Client::HTTP::ResponseCacheCheck
+
+end

data/lib/restfulie/client/cache/restrictions.rb

@@ -0,0 +1,15 @@
+module Restfulie::Client::Cache
+  
+  # Cache restrictions that allow you to cache this response or not
+  module Restrictions
+    class << self
+
+      # checks whether this request verb and its cache headers allow caching
+      def may_cache?(response)
+        response && response.may_cache?
+      end
+
+    end
+
+  end
+end

data/lib/restfulie/client/cache.rb

@@ -0,0 +1,11 @@
+module Restfulie
+  module Client
+    module Cache
+      autoload :Basic, 'restfulie/client/cache/basic'
+      autoload :Fake, 'restfulie/client/cache/fake'
+      autoload :Restrictions, 'restfulie/client/cache/restrictions'
+    end
+  end
+end
+require 'restfulie/client/cache/http_ext'
+

data/lib/restfulie/client/configuration.rb

@@ -0,0 +1,67 @@
+module Restfulie
+  module Client #:nodoc:
+    # Use this class to configure the entry point and other relevant behaviors related to accessing or interacting with resources
+    # 
+    # The available options are:
+    # 
+    # * <tt>:entry_point</tt> - The URI for an entry point, such as http://resource.entrypoint.com/post
+    # * <tt>:representations</tt> - Representations.
+    # 
+    # You can also store any other custom configuration.
+    # 
+    # ==== Example
+    # 
+    #   configuration = Configuration.new
+    #   configuration[:entry_point] = 'http://resource.entrypoint.com/post'
+    #   configuration[:entry_point] # => 'http://resource.entrypoint.com/post'
+    # 
+    # or you can use:
+    # 
+    #   configuration.entry_point = 'http://resource.entrypoint.com/post'
+    #   configuration.entry_point # => 'http://resource.entrypoint.com/post'
+    class Configuration < ::Hash
+      # the current environment
+      attr_reader :environment
+  
+      @@default_configuration = {
+        :entry_point     => '',
+        :representations => {}
+      }
+  
+      def initialize
+        super
+        self.environment = :development
+      end
+  
+      # this will store a new configuration (based on the default) for the environment passed by value.
+      def environment=(value)
+        @environment = value
+        unless has_key?(@environment) 
+          dee_clone = Marshal::load(Marshal::dump(@@default_configuration))
+          store(@environment,dee_clone)
+        end
+        @environment
+      end
+  
+      # access (key) configuration value
+      def [](key)
+        fetch(@environment)[key]
+      end
+  
+      # store on (key) configuration the value
+      def []=(key,value)
+        fetch(@environment)[key] = value
+      end 
+  
+      def method_missing(name, *args, &block)
+        method_name = name.to_s
+        if method_name.last == '='
+          fetch(environment)[method_name.chop.to_sym] = args[0]
+        else
+          value = fetch(environment)[name]
+          value ? value : super
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/client/dsl.rb

@@ -0,0 +1,52 @@
+module Restfulie::Client
+  class Dsl
+
+    def initialize
+      @requests = []
+      trait :base
+      trait :verb
+      request :base_request
+      request :rescue_exception
+      request :setup_header
+      request :serialize_body
+      request :enhance_response
+      # request :cache
+      request :follow_request
+    end
+    
+    def request(what, *args)
+      req = "Restfulie::Client::Feature::#{what.to_s.classify}".constantize
+      @requests << {:type => req, :args => args}
+      self
+    end
+
+    def trait(sym)
+      t = "Restfulie::Client::Feature::#{sym.to_s.classify}".constantize
+      self.extend t
+      self
+    end
+
+    def method_missing(sym, *args)
+      if Restfulie::Client::Feature.const_defined? sym.to_s.classify
+        loaded = true
+        trait sym
+      end
+      if Restfulie::Client::Feature.const_defined? "#{sym.to_s.classify}Request"
+        loaded = true
+        request "#{sym.to_s}Request", *args
+      end
+      if loaded
+        self
+      else
+        super sym, *args
+      end
+    end
+    
+    def request_flow(env = {})
+      Restfulie::Common::Logger.logger.debug "ready to execute request using stack #{@requests}"
+      StackNavigator.new(@requests).continue(self, env)
+    end
+
+  end  
+
+end

data/lib/restfulie/client/entry_point.rb

@@ -0,0 +1,61 @@
+
+module Restfulie
+  module Client#:nodoc
+    
+    module HTTP::RecipeModule
+      def recipe(converter_sym, options={}, &block)
+        raise 'Undefined block' unless block_given?
+        converter = "Tokamak::#{converter_sym.to_s.camelize}".constantize
+        converter.describe_recipe(options[:name], &block) 
+      end
+
+      @resources_configurations = {}
+      def configuration_of(resource_name)
+        @resources_configurations[resource_name]
+      end
+
+      def configuration_for(resource_name,configuration = Configuration.new)
+        yield configuration if block_given?
+        @resources_configurations[resource_name] = configuration
+      end
+
+      def retrieve(resource_name)
+        returning Object.new do |resource| 
+          resource.extend(Base)
+          resource.configure
+        end
+      end
+    end
+    
+    class HTTP::Recipe < MasterDelegator
+
+      def initialize(requester)
+        @requester = requester
+        @resources_configurations = {}
+      end
+      
+      include Restfulie::Client::HTTP::RecipeModule
+
+    end
+    
+    class EntryPoint
+      
+      @resources_configurations = {}
+      extend Restfulie::Client::HTTP::RecipeModule
+      
+      def initialize(requester)
+        @requester = requester
+      end
+
+      def self.at(uri)
+        Restfulie.using {
+          recipe
+          follow_link
+          request_marshaller
+          verb_request
+        }.at(uri)
+      end
+
+    end
+  end
+end

data/lib/restfulie/client/ext/http_ext.rb

@@ -0,0 +1,22 @@
+module Net
+  class HTTP
+    # Definition of a patch method in the same way that post works
+    def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
+      res = nil
+      request(Patch.new(path, initheader), data) {|r|
+        r.read_body dest, &block
+        res = r
+      }
+      unless @newimpl
+        res.value
+        return res, res.body
+      end
+      res
+    end
+
+    class Patch < Get
+      METHOD = "PATCH"
+    end
+  end
+end
+

data/lib/restfulie/client/ext/link_ext.rb

@@ -0,0 +1,11 @@
+module Medie
+  class Link
+    
+    # allows you to follow links by using restfulie
+    def follow
+      r = Restfulie.at(href)
+      r = r.as(content_type) if content_type
+      r
+    end
+  end
+end

data/lib/restfulie/client/ext/open_search_ext.rb

@@ -0,0 +1,26 @@
+module Medie
+  module OpenSearch
+    class Descriptor
+      
+      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
+  end
+end

data/lib/restfulie/client/ext.rb

@@ -0,0 +1,3 @@
+require 'restfulie/client/ext/link_ext'
+require 'restfulie/client/ext/http_ext'
+require 'restfulie/client/ext/open_search_ext'

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

@@ -0,0 +1,75 @@
+module Restfulie::Client::Feature
+  module Base
+  
+    attr_reader :default_headers, :cookies, :verb, :host
+    attr_writer :headers
+  
+    #Set host
+    def at(url)
+      if self.host.nil?
+        self.host= url
+      else
+        self.host= self.host + url
+      end
+      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)
+      headers.merge!(headers)
+      self
+    end
+
+    # Path (e.g. http://restfulie.com/posts => /posts)
+    def path
+      host.path + (host.query.nil? ? "" : "?#{host.query}")
+    end
+
+    def host=(host)
+      if host.is_a?(::URI)
+        @host = host
+      else
+        @host = ::URI.parse(host)
+      end
+    end
+
+    def default_headers
+      @default_headers ||= {}
+    end
+
+    def headers
+      @headers ||= {}
+    end
+
+    def http_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

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

@@ -0,0 +1,46 @@
+class Restfulie::Client::Feature::BaseRequest
+
+  def execute(flow, request, env)
+    request!(request.verb, request.host, request.path, request, flow, env)
+  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, host, path, request, flow, env)
+
+    ::Restfulie::Common::Logger.logger.info(request.http_to_s(method, path, [request.headers])) if ::Restfulie::Common::Logger.logger
+    http_request = get_connection_provider(host, env)
+
+    if env[:body]
+      enhance http_request.send(method, path, env[:body], request.headers)
+    else
+      enhance http_request.send(method, path, request.headers)
+    end
+    
+  end
+
+  protected
+
+  def get_connection_provider(uri, env)
+    @connection ||= create_connection(uri, env)
+  end
+
+  private
+  def create_connection(uri, env)
+    result = ::Net::HTTP.new(uri.host, uri.port)
+    result.use_ssl = true if uri.scheme == 'https'
+    ssl_verify_mode = env[:ssl_verify_mode]
+    result.verify_mode = ssl_verify_mode if ssl_verify_mode
+    result
+  end
+
+  def enhance(response)
+    def response.code
+      super.to_i
+    end
+    response
+  end
+  
+end

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

@@ -0,0 +1,16 @@
+class Restfulie::Client::Feature::Cache
+  
+  def execute(flow, request, env)
+    found = Restfulie::Client.cache_provider.get([request.host, request.path], request)
+    return found if found
+    
+    resp = flow.continue(request, env)
+    if resp.kind_of?(Exception)
+      resp
+    else
+      Restfulie::Client.cache_provider.put([request.host, request.path], request, resp)
+      resp
+    end
+  end
+  
+end

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

@@ -0,0 +1,25 @@
+# Retries marshalling to an acceptable media type if
+# the server returns with 406: content negotiation. This means looking for
+# another media type that both server and client
+# understands, picking its converter and using it
+# to marshal the original payload again.
+#
+# To use it, load it in your dsl:
+# Restfulie.at("http://localhost:3000/product/2").conneg_when_unaccepted.get
+module Restfulie::Client::Feature
+  class ConnegWhenUnaccepted
+    
+  	def execute(chain, request, env)
+			resp = chain.continue(request, env)
+			return resp if resp.code!=406
+		  
+			accept = Medie.registry.for(resp.headers["Accept"])
+		  return resp if accept.nil?
+		  
+    	request.with("Content-type", accept)
+    	env = env.dup.merge(:body => env[:payload])
+    	Restfulie::Client::Feature::SerializeBody.new.execute(chain, request, env)
+  	end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+module Restfulie::Client::Feature
+  class EnhanceResponse
+    def execute(flow, request, env)
+      resp = flow.continue(request, env)
+      unless resp.kind_of? ::Restfulie::Client::HTTP::ResponseHolder
+        resp.extend(::Restfulie::Client::HTTP::ResponseHolder)
+        resp.results_from request, resp
+      end
+      resp
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Restfulie
+  module Client
+    module Feature
+      class FakeResponse
+        attr_reader :code, :body
+        def initialize(code, body)
+          @code = code
+          @body = body
+        end
+      end
+    end
+  end
+end