restfulie 0.1.0.beta1

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,13 @@
+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/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,66 @@
+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

@@ -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 = "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

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

@@ -0,0 +1,14 @@
+# Atom links now can be followed
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class Link
+          def follow
+            Restfulie.at(href).as(type)
+          end
+        end
+      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/json_ext.rb

@@ -0,0 +1,16 @@
+# inject new behavior in Atom instances to enable easily access to link relationships.
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        class Link
+          def follow
+            r = Restfulie.at(href)
+            r = r.as(type) if type
+            r
+          end
+        end
+      end
+    end
+  end
+end

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,35 @@
+class Restfulie::Client::Feature::BaseRequest
+  
+  def execute(flow, request, response, 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
+    begin
+      http_request = get_connection_provider(host)
+
+      if env[:body]
+        response = http_request.send(method, path, env[:body], request.headers)
+      else
+        response = http_request.send(method, path, request.headers)
+      end
+
+    rescue Exception => e
+      response = e
+    end
+    
+    flow.continue(request, response, env)
+    
+  end
+
+  def get_connection_provider(host)
+    @connection ||= ::Net::HTTP.new(host.host, host.port)
+  end
+  
+end

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

@@ -0,0 +1,16 @@
+class Restfulie::Client::Feature::Cache
+  
+  def execute(flow, request, response, env)
+    found = Restfulie::Client.cache_provider.get([request.host, request.path], request)
+    return found if found
+    
+    resp = flow.continue(request, response, 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/enhance_response.rb

@@ -0,0 +1,12 @@
+module Restfulie::Client::Feature
+  class EnhanceResponse
+    def execute(flow, request, response, env)
+      resp = flow.continue(request, response, 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/follow_request.rb

@@ -0,0 +1,41 @@
+# ==== 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, response, env)
+    resp = flow.continue(request, response, env)
+    if !resp.respond_to?(:code)
+      return resp
+    end
+    code = resp.code.to_i
+    if follow_codes.include?(code)
+      if code==201 && !resp.body.empty?
+        resp
+      else
+        location = resp.response.headers['location'] || resp.response.headers['Location']
+        raise Error::AutoFollowWithoutLocationError.new(request, resp) unless location
+        # use the first location available
+        location = location[0]
+        Restfulie.at(location).accepts(request.headers['Accept']).get
+      end
+    else
+      resp
+    end
+  end
+
+  protected
+
+    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,19 @@
+# ==== RequestHistory
+# Uses RequestBuilder and remind previous requests
+#
+# ==== Example:
+#
+#   @executor = ::Restfulie::Client::HTTP::RequestHistoryExecutor.new("http://restfulie.com") #this class includes RequestHistory module.
+#   @executor.at('/posts').as('application/xml').accepts('application/atom+xml').with('Accept-Language' => 'en').get.code #=> 200 #first request
+#   @executor.at('/blogs').as('application/xml').accepts('application/atom+xml').with('Accept-Language' => 'en').get.code #=> 200 #second request
+#   @executor.request_history!(0) #doing first request
+#
+class Restfulie::Client::Feature::HistoryRequest
+
+  def execute(flow, request, response, env)
+    resp = flow.continue(request, response, 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