pezra-resourceful 0.5.4

data/lib/resourceful/response.rb

@@ -0,0 +1,222 @@
+require 'net/http'
+require 'time'
+require 'zlib'
+
+module Resourceful
+
+  class Response
+    REDIRECT_RESPONSE_CODES = [301,302,303,307]
+    NORMALLY_CACHEABLE_RESPONSE_CODES = [200, 203, 300, 301, 410]
+
+    attr_reader :uri, :code, :header, :body, :response_time
+    alias headers header
+
+    attr_accessor :authoritative, :request_time
+    alias authoritative? authoritative
+
+    def initialize(uri, code, header, body)
+      @uri, @code, @header, @body = uri, code, header, body
+      @response_time = Time.now
+    end
+
+    # Is this a cached response that has expired?
+    #
+    # @return true|false
+    def expired?
+      if header['Cache-Control'] and header['Cache-Control'].first.include?('max-age')
+        max_age = header['Cache-Control'].first.split(',').grep(/max-age/).first.split('=').last.to_i
+        return true if current_age > max_age
+      elsif header['Expire']
+        return true if Time.httpdate(header['Expire'].first) < Time.now
+      end
+
+      false
+    end
+
+    # Is this a cached response that is stale?
+    #
+    # @return true|false
+    def stale?
+      return true if expired?
+      if header['Cache-Control']
+        return true if header['Cache-Control'].include?('must-revalidate')
+        return true if header['Cache-Control'].include?('no-cache')
+      end
+
+      false
+    end
+
+    # Is this response cachable?
+    #
+    # @return true|false
+    def cacheable?
+      @cacheable ||= begin
+        @cacheable = true  if NORMALLY_CACHEABLE_RESPONSE_CODES.include?(code.to_i)
+        @cacheable = false if header.vary && header.vary.include?('*')
+        @cacheable = false if header.cache_control && header.cache_control.include?('no-cache')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('public')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('private')
+        @cacheable || false
+      end
+    end
+
+    # Does this response force revalidation?
+    def must_be_revalidated?
+      header.cache_control && header.cache_control.include?('must-revalidate')
+    end
+    
+    # Update our headers from a later 304 response
+    def revalidate!(not_modified_response)
+      header.merge!(not_modified_response.header)
+      @request_time  = not_modified_response.request_time
+      @response_time = not_modified_response.response_time
+      @authoritative = true
+    end
+
+    # Algorithm taken from RCF2616#13.2.3
+    def current_age
+      age_value   = header['Age'] ? header['Age'].first.to_i : 0
+      date_value  = Time.httpdate(header['Date'].first)
+      now         = Time.now
+
+      apparent_age = [0, response_time - date_value].max
+      corrected_received_age = [apparent_age, age_value].max
+      current_age = corrected_received_age + (response_time - request_time) + (now - response_time)
+    end
+
+    def body
+      encoding = header['Content-Encoding'] && header['Content-Encoding'].first
+      case encoding
+      when nil
+        # body is identity encoded; just return it
+        @body
+      when /^\s*gzip\s*$/i
+        gz_in = ::Zlib::GzipReader.new(StringIO.new(@body, 'r'))
+        @body = gz_in.read
+        gz_in.close
+        header.delete('Content-Encoding')
+        @body
+      else
+        raise UnsupportedContentCoding, "Resourceful does not support #{encoding} content coding" 
+      end
+    end
+
+    CODE_NAMES = {
+      100 => "Continue".freeze,
+      101 => "Switching Protocols".freeze,
+
+      200 => "OK".freeze,
+      201 => "Created".freeze,
+      202 => "Accepted".freeze,
+      203 => "Non-Authoritative Information".freeze,
+      204 => "No Content".freeze,
+      205 => "Reset Content".freeze,
+      206 => "Partial Content".freeze,
+
+      300 => "Multiple Choices".freeze,
+      301 => "Moved Permanently".freeze,
+      302 => "Found".freeze,
+      303 => "See Other".freeze,
+      304 => "Not Modified".freeze,
+      305 => "Use Proxy".freeze,
+      307 => "Temporary Redirect".freeze,
+
+      400 => "Bad Request".freeze,
+      401 => "Unauthorized".freeze,
+      402 => "Payment Required".freeze,
+      403 => "Forbidden".freeze,
+      404 => "Not Found".freeze,
+      405 => "Method Not Allowed".freeze,
+      406 => "Not Acceptable".freeze,
+      407 => "Proxy Authentication Required".freeze,
+      408 => "Request Timeout".freeze,
+      409 => "Conflict".freeze,
+      410 => "Gone".freeze,
+      411 => "Length Required".freeze,
+      412 => "Precondition Failed".freeze,
+      413 => "Request Entity Too Large".freeze,
+      414 => "Request-URI Too Long".freeze,
+      415 => "Unsupported Media Type".freeze,
+      416 => "Requested Range Not Satisfiable".freeze,
+      417 => "Expectation Failed".freeze,
+
+      500 => "Internal Server Error".freeze,
+      501 => "Not Implemented".freeze,
+      502 => "Bad Gateway".freeze,
+      503 => "Service Unavailable".freeze,
+      504 => "Gateway Timeout".freeze,
+      505 => "HTTP Version Not Supported".freeze,
+    }.freeze
+
+    CODES = CODE_NAMES.keys
+
+    CODE_NAMES.each do |code, msg|
+      method_name = msg.downcase.gsub(/[- ]/, "_")
+
+      class_eval <<-RUBY
+        def #{method_name}?                           # def ok?
+          @code == #{code}                            #   @code == 200
+        end                                           # end
+      RUBY
+    end
+
+    # Is the response informational? True for
+    # 1xx series response codes
+    #
+    # @return true|false
+    def informational?
+      @code.in? 100..199
+    end
+
+    # Is the response code sucessful? True for only 2xx series
+    # response codes.
+    #
+    # @return true|false
+    def successful?
+      @code.in? 200..299
+    end
+    alias success? successful?
+
+    # Is the response a redirect? True for
+    # 3xx series response codes
+    #
+    # @return true|false
+    def redirection?
+      @code.in? 300..399
+    end
+
+    # Is the response a actual redirect? True for
+    # 301, 302, 303, 307 response codes
+    #
+    # @return true|false
+    def redirect?
+      @code.in? REDIRECT_RESPONSE_CODES
+    end
+
+    # Is the response the result of a client error? True for
+    # 4xx series response codes
+    #
+    # @return true|false
+    def client_error?
+      @code.in? 400..499
+    end
+
+    # Is the response the result of a server error? True for
+    # 5xx series response codes
+    #
+    # @return true|false
+    def server_error?
+      @code.in? 500..599
+    end
+
+    # Is the response the result of any kind of error? True for
+    # 4xx and 5xx series response codes
+    #
+    # @return true|false
+    def error?
+      server_error? || client_error?
+    end
+
+  end
+  
+end

data/lib/resourceful/stubbed_resource_proxy.rb

@@ -0,0 +1,47 @@
+require 'resourceful/resource'
+  
+module Resourceful
+  class StubbedResourceProxy
+    def initialize(resource, canned_responses)
+      @resource = resource
+      
+      @canned_responses = {}
+      
+      canned_responses.each do |cr| 
+        mime_type = cr[:mime_type]
+        @canned_responses[mime_type] = resp = Net::HTTPOK.new('1.1', '200', 'OK')
+        resp['content-type'] = mime_type.to_str
+        resp.instance_variable_set(:@read, true)
+        resp.instance_variable_set(:@body, cr[:body])
+
+      end
+    end
+
+    def get_body(*args)
+      get(*args).body
+    end
+    
+    def get(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      
+      if accept = [(options[:accept] || '*/*')].flatten.compact
+        accept.each do |mt|
+          return canned_response(mt) || next
+        end
+        @resource.get(*args)
+       end
+    end
+
+    def method_missing(method, *args)
+      @resource.send(method, *args)
+    end
+    
+    protected
+    
+    def canned_response(mime_type)
+      mime_type = @canned_responses.keys.first if mime_type == '*/*'
+      @canned_responses[mime_type]
+    end
+    
+  end
+end

data/lib/resourceful/util.rb

@@ -0,0 +1,6 @@
+
+class Object
+  def in?(arr)
+    arr.include?(self)
+  end
+end

data/resourceful.gemspec

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resourceful}
+  s.version = "0.5.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Sadauskas"]
+  s.date = %q{2009-08-07}
+  s.description = %q{An HTTP library for Ruby that takes advantage of everything HTTP has to offer.}
+  s.email = %q{psadauskas@gmail.com}
+  s.extra_rdoc_files = ["lib/resourceful/authentication_manager.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/exceptions.rb", "lib/resourceful/header.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/multipart_form_data.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/options_interpretation.rb", "lib/resourceful/request.rb", "lib/resourceful/resource.rb", "lib/resourceful/response.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/util.rb", "lib/resourceful.rb", "README.markdown"]
+  s.files = ["lib/resourceful/authentication_manager.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/exceptions.rb", "lib/resourceful/header.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/multipart_form_data.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/options_interpretation.rb", "lib/resourceful/request.rb", "lib/resourceful/resource.rb", "lib/resourceful/response.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/util.rb", "lib/resourceful.rb", "Manifest", "MIT-LICENSE", "Rakefile", "README.markdown", "resourceful.gemspec", "spec/acceptance/authorization_spec.rb", "spec/acceptance/caching_spec.rb", "spec/acceptance/header_spec.rb", "spec/acceptance/redirecting_spec.rb", "spec/acceptance/resource_spec.rb", "spec/acceptance_shared_specs.rb", "spec/caching_spec.rb", "spec/old_acceptance_specs.rb", "spec/resourceful/multipart_form_data_spec.rb", "spec/resourceful/resource_spec.rb", "spec/simple_sinatra_server.rb", "spec/simple_sinatra_server_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/paul/resourceful}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Resourceful", "--main", "README.markdown"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{resourceful}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{An HTTP library for Ruby that takes advantage of everything HTTP has to offer.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<addressable>, [">= 2.1.0"])
+      s.add_runtime_dependency(%q<httpauth>, [">= 0"])
+      s.add_development_dependency(%q<thin>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<sinatra>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<addressable>, [">= 2.1.0"])
+      s.add_dependency(%q<httpauth>, [">= 0"])
+      s.add_dependency(%q<thin>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<addressable>, [">= 2.1.0"])
+    s.add_dependency(%q<httpauth>, [">= 0"])
+    s.add_dependency(%q<thin>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/spec/acceptance/authorization_spec.rb

@@ -0,0 +1,16 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "basic auth" do
+
+  end
+
+  describe "digest auth" do
+
+  end
+
+end
+

data/spec/acceptance/caching_spec.rb

@@ -0,0 +1,190 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+require 'addressable/template'
+
+describe Resourceful do
+
+  describe "caching" do
+
+    before do
+      @http = Resourceful::HttpAccessor.new(:cache_manager => Resourceful::InMemoryCacheManager.new)
+      if ENV['SPEC_LOGGING']
+        @http.logger = Resourceful::StdOutLogger.new
+      end
+    end
+
+    def get_with_errors(resource)
+      begin
+        resp = resource.get
+      rescue Resourceful::UnsuccessfulHttpRequestError => e
+        resp = e.http_response
+      end
+      resp
+    end
+
+    def uri_plus_params(uri, params = {})
+      uri = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
+      uri.query_values = params
+      uri
+    end
+
+    def uri_for_code(code, params = {})
+      uri = Addressable::Template.new("http://localhost:42682/code/{code}").expand("code" => code.to_s)
+      uri_plus_params(uri, params)
+    end
+
+    describe "response cacheability" do
+      Resourceful::Response::NORMALLY_CACHEABLE_RESPONSE_CODES.each do |code|
+        describe "response code #{code}" do
+          it "should normally be cached" do
+            resource = @http.resource(uri_for_code(code))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+
+          it "should not be cached if Vary: *" do
+            resource = @http.resource(uri_for_code(200, "Vary" => "*"))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+
+          it "should not be cached if Cache-Control: no-cache'" do
+            resource = @http.resource(uri_for_code(200, "Cache-Control" => "no-cache"))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+        end
+      end
+
+      # I would prefer to do all other codes, but some of them do some magic stuff (100),
+      # so I'll just spot check. 
+      [201, 206, 302, 307, 404, 500].each do |code|
+        describe "response code #{code}" do
+          it "should not normally be cached" do
+            resource = @http.resource(uri_for_code(code))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+          
+          it "should be cached if Cache-Control: public" do
+            resource = @http.resource(uri_for_code(code, "Cache-Control" => "public"))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+
+          it "should be cached if Cache-Control: private" do
+            resource = @http.resource(uri_for_code(code, "Cache-Control" => "private"))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+        end
+      end
+
+    end
+
+    describe "expiration" do
+      it 'should use the cached response if Expire: is in the future' do
+        in_the_future = (Time.now + 60).httpdate
+        resource = @http.resource(uri_for_code(200, "Expire" => in_the_future))
+
+        resp = resource.get
+        resp.should_not be_expired
+
+        resp = resource.get
+        resp.should be_ok
+        resp.should_not be_authoritative
+      end
+
+      it 'should revalidate the cached response if the response is expired' do
+        in_the_past = (Time.now - 60).httpdate
+        resource = @http.resource(uri_for_code(200, "Expire" => in_the_past))
+
+        resp = resource.get
+        resp.should be_expired
+
+        resp = resource.get
+        resp.should be_ok
+        resp.should be_authoritative
+      end
+    end
+
+    describe 'authoritative' do
+
+      it "should be authoritative if the response is directly from the server" do
+        resource = @http.resource(
+          uri_plus_params('http://localhost:42682/', "Cache-Control" => 'max-age=10')
+        )
+
+        response  = resource.get
+        response.should be_authoritative
+      end
+
+      it "should be authoritative if a cached response was revalidated with the server" do
+        now = Time.now.httpdate
+        resource = @http.resource(
+          uri_plus_params('http://localhost:42682/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=0')
+        )
+
+        resource.get
+        response = resource.get("Cache-Control" => "max-age=0")
+        response.should be_authoritative
+      end
+
+      it "should not be authoritative if the cached response was not revalidated" do
+        now = Time.now.httpdate
+        resource = @http.resource(
+          uri_plus_params('http://localhost:42682/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=10')
+        )
+
+        resource.get
+        response = resource.get
+        response.should_not be_authoritative
+
+      end
+
+    end
+    
+    describe "Not Modified responses" do
+      before do
+        now = Time.now.httpdate
+
+        resource = @http.resource(
+          uri_plus_params('http://localhost:42682/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=0')
+        )
+
+        @first_response  = resource.get
+        @second_response = resource.get("Cache-Control" => "max-age=0") # Force revalidation
+      end
+
+      it "should replace the 304 response with whats in the cache" do
+        @second_response.code.should == @first_response.code
+      end
+
+      it "should provide a body identical to the original response" do
+        @second_response.body.should == @first_response.body
+      end
+
+      it "should override any cached headers with new ones"
+    end
+
+    describe "cache invalidation" do
+
+    end
+
+  end
+
+end
+