restfulie 0.9.3 → 1.0.0.beta1

data/Gemfile

@@ -9,6 +9,8 @@ gem "json_pure"
 gem "sqlite3-ruby"
 gem "yard"
 
+gem "respondie"
+
 if RUBY_VERSION < "1.9"
   gem "ruby-debug"
 else

data/Gemfile.lock

@@ -72,7 +72,7 @@ GEM
       thor (~> 0.14.0)
     rake (0.8.7)
     rcov (0.9.8)
-    responders_backport (0.1.2)
+    respondie (0.9.0)
     rspec (2.0.0.beta.19)
       rspec-core (= 2.0.0.beta.19)
       rspec-expectations (= 2.0.0.beta.19)
@@ -118,7 +118,7 @@ DEPENDENCIES
   rack-conneg
   rails (>= 3.0.0)
   rcov
-  responders_backport
+  respondie
   rspec-rails (>= 2.0.0.beta.19)
   ruby-debug
   sinatra

data/README.textile

@@ -51,7 +51,7 @@ That's it. Restfulie will take care of rendering a valid representation accordin
 	end
 </pre>
 
-You can go through an entire application by "watching this video":http://guilhermesilveira.wordpress.com or "downloading an example application":http://github.com/caelum/mikyung.
+You can go through an entire application by "watching this video":http://guilhermesilveira.wordpress.com or "downloading an example application contained within the restfulie ":http://github.com/caelum/restfulie/tree/master/full-examples/rest_from_scratch/
 
 h2. Simple client example
 
@@ -70,7 +70,7 @@ h2. Full examples
 
 You can view an entire application running Restfulie under *spec/integration/order/server* and *spec/integration/order/client* in this git repository.
 
-"You can also download a full example of a REST based agent and server":http://github.com/caelum/full-restfulie-examples using Restfulie, according to the Rest Architecture Maturity Model.
+"You can also download a full example of a REST based agent and server":http://github.com/caelum/restfulie/tree/master/full-examples/rest_from_scratch/ using Restfulie, according to the Rest Architecture Maturity Model.
 
 h2. Documentation
 
@@ -89,6 +89,8 @@ Execute:
 gem install restfulie
 </pre>
 
+For use in Rails 2.3, make sure to require the responders_backport gem in addition to the restfulie gem, either in environment.rb or in the Gemfile.
+
 h2. Building the project
 
 If you want to build the project and run its tests, remember to install all (client and server) required gem. 

data/Rakefile

@@ -95,23 +95,22 @@ namespace :test do
     FakeServer.start_server_and_run_spec "full-examples/rest_from_scratch/part_3"
   end
   
-  task :all => ["spec","integration"]
+  task :sinatra do
+    FakeServer.start_sinatra do
+      puts "Press something to quit"
+      gets
+    end
+  end
   
-  # namespace :rcov do
-  #   Spec::Rake::SpecTask.new('rcov') do |t|
-  #       t.spec_opts = %w(-fs --color)
-  #       t.spec_files = FileList['spec/units/**/*_spec.rb']
-  #       t.rcov = true
-  #       t.rcov_opts = ["-e", "/Library*", "-e", "~/.rvm", "-e", "spec", "-i", "bin"]
-  #     end
-  #     desc 'Run coverage test with fake server'
-  #     task :run do
-  #       start_server_and_invoke_test('test:rcov:rcov')
-  #     end
-  # end
+  task :all => ["spec","integration"]
   
 end
 
+RSpec::Core::RakeTask.new(:spec) do |t|
+  # t.spec_files = FileList['spec_*.rb']
+  t.spec_opts = ['--colour', '--format progress']
+end
+
 Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end

data/lib/restfulie/client/base.rb

@@ -1,7 +1,14 @@
 module Restfulie
   module Client#:nodoc
     module Base
-      include HTTP::RequestMarshaller
+      
+      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)
@@ -15,7 +22,7 @@ module Restfulie
       def configure
         configuration = EntryPoint.configuration_of(resource_name)
         raise "Undefined configuration for #{resource_name}" unless configuration
-        at(configuration.entry_point)
+        @base_position = Restfulie.at(configuration.entry_point)
         configuration.representations.each do |representation_name,representation|
           register_representation(representation_name,representation)
         end

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

@@ -14,10 +14,10 @@ module Restfulie::Client::Cache
       response
     end
 
-    def get(key, request, verb)
+    def get(key, request)
 
       # debugger
-      response = cache_get(key, request, verb)
+      response = cache_get(key, request)
       return nil if response.nil?
 
       if response.has_expired_cache?
@@ -47,13 +47,14 @@ module Restfulie::Client::Cache
       cache.write(key, values)
     end
 
-    def cache_get(key, req, verb)
+    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
-        if old_response.vary_headers_for(old_req) == old_response.vary_headers_for(req) &&
-          old_response.method == verb
+        
+        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

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

@@ -59,13 +59,13 @@ module Restfulie::Client::HTTP::ResponseCacheCheck
   
   def has_expired_cache?
     return true if headers['date'].nil?
-    max_time = Time.rfc2822(headers['date']) + cache_max_age.seconds
+    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_field?(headers['cache-control'])
+    may_cache_method? && may_cache_field?(headers['cache-control'])
   end
   
   # Returns whether this cache control field allows caching
@@ -86,16 +86,13 @@ module Restfulie::Client::HTTP::ResponseCacheCheck
     max_age_header = value_for(field, /^max-age=(\d+)/)
     return false if max_age_header.nil?
     
-    if value_for(field, /^no-store/)
-      false
-    else
-      true
-    end
+    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
   
@@ -113,9 +110,14 @@ module Restfulie::Client::HTTP::ResponseCacheCheck
     end
   end
     
+  private
+  def may_cache_method?
+    verb == :get || verb == :post
+  end
 end
 
-class Restfulie::Client::HTTP::Response
+class Net::HTTPResponse
   include Restfulie::Client::HTTP::ResponseStatus
   include Restfulie::Client::HTTP::ResponseCacheCheck
+
 end

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

@@ -4,12 +4,7 @@ module Restfulie::Client::Cache
 
       # checks whether this request verb and its cache headers allow caching
       def may_cache?(response)
-        may_cache_method?(response.method) && response.may_cache?
-      end
-
-      # only Post and Get requests are cacheable so far
-      def may_cache_method?(verb)
-        verb == :get || verb == :post
+        response && response.may_cache?
       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

@@ -1,14 +1,8 @@
+
 module Restfulie
   module Client#:nodoc
-    module EntryPoint
-      include HTTP::RequestMarshaller
-      include HTTP::RequestFollow
-      extend self
-
-      def self.at(uri)
-        Object.new.send(:extend, EntryPoint).at(uri)
-      end
-
+    
+    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
@@ -32,5 +26,36 @@ module Restfulie
         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

@@ -1,10 +1,12 @@
-# inject new behavior in Atom instances to enable easily access to link relationships.
+# Atom links now can be followed
 module Restfulie
   module Common
     module Representation
       module Atom
         class Link
-          include Restfulie::Client::HTTP::LinkRequestBuilder
+          def follow
+            Restfulie.at(href).as(type)
+          end
         end
       end
     end

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

@@ -4,7 +4,11 @@ module Restfulie
     module Representation
       class Json
         class Link
-          include Restfulie::Client::HTTP::LinkRequestBuilder
+          def follow
+            r = Restfulie.at(href)
+            r = r.as(type) if type
+            r
+          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

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