restfulie 0.1.0.beta1 → 0.1

data/lib/restfulie/client/base.rb

@@ -1,36 +0,0 @@
-module Restfulie
-  module Client#:nodoc
-    module Base
-      
-      def method_missing(sym, *args, &block)
-        if @base_position.respond_to?(sym)
-          @base_position.send sym, *args, &block
-        else
-          super(sym, *args, &block)
-        end
-      end
-     
-      def self.included(base)#:nodoc
-        base.extend(self)
-      end
-  
-      def uses_restfulie(configuration = Configuration.new,&block)
-        EntryPoint.configuration_for(resource_name,configuration,&block)
-        configure
-      end
-  
-      def configure
-        configuration = EntryPoint.configuration_of(resource_name)
-        raise "Undefined configuration for #{resource_name}" unless configuration
-        @base_position = Restfulie.at(configuration.entry_point)
-        configuration.representations.each do |representation_name,representation|
-          register_representation(representation_name,representation)
-        end
-      end
-  
-      def resource_name
-        @resource_name ||= self.class.to_s.to_sym 
-      end
-    end
-  end
-end

data/lib/restfulie/client/cache.rb

@@ -1,11 +0,0 @@
-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/cache/basic.rb

@@ -1,76 +0,0 @@
-# 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)
-
-      # debugger
-      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
-
-  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
-
-    def cache
-      Restfulie::Client.cache_store
-    end
-
-  end
-end

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

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

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

@@ -1,13 +0,0 @@
-module Restfulie::Client::Cache
-  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/configuration.rb

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

@@ -1,66 +0,0 @@
-module Restfulie::Client
-  class Dsl
-
-    def initialize
-      @requests = []
-      trait :base
-      trait :verb
-      request :base_request
-      request :setup_header
-      request :serialize_body
-      request :enhance_response
-      # request :cache
-      request :follow_request
-    end
-    
-    def request(what)
-      req = "Restfulie::Client::Feature::#{what.to_s.classify}".constantize
-      @requests << req
-      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"
-      end
-      if loaded
-        self
-      else
-        super sym, *args
-      end
-    end
-    
-    def request_flow(env = {})
-      Parser.new(@requests).continue(self, nil, env)
-    end
-
-  end
-  
-  class Parser
-    
-    def initialize(stack)
-      @stack = stack.dup
-    end
-    
-    def continue(request, response, env)
-      current = @stack.pop
-      if current.nil?
-        return response
-      end
-      filter = current.new
-      filter.execute(self, request, response, env)
-    end
-    
-  end
-end

data/lib/restfulie/client/entry_point.rb

@@ -1,61 +0,0 @@
-
-module Restfulie
-  module Client#:nodoc
-    
-    module HTTP::RecipeModule
-      def recipe(converter_sym, options={}, &block)
-        raise 'Undefined block' unless block_given?
-        converter = "Restfulie::Common::Converter::#{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