cacho 0.0.1 → 0.0.2

data/cacho.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name              = "cacho"
-  s.version           = "0.0.1"
+  s.version           = "0.0.2"
   s.summary           = "Cache aware, Redis based HTTP client."
   s.description       = "HTTP client that understands cache responses and stores results in Redis."
   s.authors           = ["Damian Janowski", "Michel Martens"]

data/lib/cacho.rb

@@ -1,104 +1,136 @@
+# encoding: UTF-8
+
+require "json" unless defined?(JSON)
 require "curb"
-require "redis"
-require "json"
+require "nest"
 
 class Cacho
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 
   def self.get(url, request_headers = {})
-    response = Local.get(url)
+    _request(:get, url, request_headers)
+  end
 
-    if response.nil?
-      response = Remote.get(url, Local.validation_for(url).merge(request_headers))
-      Local.set(url, response)
+  def self.head(url, request_headers = {})
+    _request(:head, url, request_headers)
+  end
+
+  def self.options(url, request_headers = {})
+    _request(:options, url, request_headers)
+  end
+
+  def self._request(verb, url, request_headers = {})
+    local = Local[verb, url]
+
+    unless local.fresh?
+      remote = Remote.request(verb, url, local.build_headers.merge(request_headers))
+
+      local.set(remote) unless remote.first == 304
     end
 
-    response
+    local.response
   end
 
   class Local
-    def self.get(url)
-      expire, json = redis.hmget(url, :expire, :response)
+    attr :etag
+    attr :last_modified
+    attr :expire
+    attr :response
+
+    def initialize(key)
+      @key = key
+      @etag, @last_modified, @expire, @response = @key.hmget(:etag, :last_modified, :expire, :response)
+      @response = JSON.parse(@response) if @response
+    end
 
-      if json && (expire.nil? || Time.utc(expire) <= Time.now)
-        JSON.parse(json)
+    def self.[](verb, url)
+      new(Nest.new(verb)[url])
+    end
+
+    def expire_in(ttl)
+      @expire = (Time.now + ttl).to_i
+    end
+
+    def build_headers
+      {}.tap do |headers|
+        headers["If-None-Match"] = etag if etag
+        headers["If-Modified-Since"] = last_modified if last_modified
       end
     end
 
-    def self.set(url, response)
-      return unless cacheable?(response)
+    def set(response)
+      @response = response
 
-      _, headers, _ = response
+      return unless cacheable?
 
-      fields = {}
+      _, headers, _ = response
 
       if headers["Cache-Control"]
         ttl = headers["Cache-Control"][/max\-age=(\d+)/, 1].to_i
-
-        fields[:expire] = (Time.now + ttl).to_i
+        expire_in(ttl)
       end
 
-      fields[:response] = response.to_json
+      @etag = headers["ETag"]
+      @last_modified = headers["Last-Modified"]
 
-      fields[:etag] = headers["Etag"]
-      fields[:last_modified] = headers["Last-Modified"]
-
-      redis.hmset(url, *fields.to_a.flatten)
+      store
     end
 
-    def self.validation_for(url)
-      etag, last_modified = redis.hmget(url, :etag, :last_modified)
-
-      {}.tap do |headers|
-        headers["If-None-Match"] = etag if etag
-        headers["If-Modified-Since"] = last_modified if last_modified
-      end
+    def fresh?
+      expire && expire.to_i >= Time.now.to_i
     end
 
-    def self.cacheable?(response)
+  protected
+
+    def cacheable?
       status, headers, _ = response
 
-      status == 200 && (headers["Cache-Control"] || headers["Etag"] || headers["Last-Modified"])
+      status == 200 && (headers["Cache-Control"] || headers["ETag"] || headers["Last-Modified"])
     end
 
-    def self.redis
-      Redis.current
+    def store
+      fields = {response: response.to_json}
+
+      fields[:etag] = etag if etag
+      fields[:last_modified] = last_modified if last_modified
+      fields[:expire] = expire if expire
+
+      @key.redis.multi do
+        @key.del
+        @key.hmset(*fields.to_a.flatten)
+      end
     end
   end
 
   class Remote
-    def self.get(url, request_headers)
+    def self.request(verb, url, request_headers)
       status = nil
       headers = {}
       body = ""
 
-      Curl::Easy.http_get(url) do |curl|
-        curl.headers = request_headers
+      curl = Curl::Easy.new(url)
 
-        curl.on_header do |header|
-          headers.store(*header.rstrip.split(": ", 2)) if header.include?(":")
-          header.bytesize
-        end
+      curl.headers = request_headers
 
-        curl.on_body do |string|
-          body << string
-          string.bytesize
-        end
+      curl.on_header do |header|
+        headers.store(*header.rstrip.split(": ", 2)) if header.include?(":")
+        header.bytesize
+      end
 
-        curl.on_complete do |response|
-          status = response.response_code
-        end
+      curl.on_body do |string|
+        body << string.force_encoding(Encoding::UTF_8)
+        string.bytesize
       end
 
-      if status == 301
-        Local.get(url)
-      else
-        [status, headers, body]
+      curl.on_complete do |response|
+        status = response.response_code
       end
-    end
 
-    def self.redis
-      Redis.current
+      curl.head = verb == :head
+
+      curl.http(verb.to_s.upcase)
+
+      [status, headers, body]
     end
   end
 end

data/test/cacho.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require "cutest"
 require "socket"
 require "mock_server"
@@ -7,10 +9,12 @@ require File.expand_path("../lib/cacho", File.dirname(__FILE__))
 include MockServer::Methods
 
 mock_server do
-  get "/cacheable" do
-    response.headers["Cache-Control"] = "public, max-age=1"
-    response.headers["Content-Type"] = "text/plain"
-    Time.now.httpdate
+  %w(GET OPTIONS).each do |method|
+    route method, "/cacheable" do
+      response.headers["Cache-Control"] = "public, max-age=2"
+      response.headers["Content-Type"] = "text/plain"
+      Time.now.httpdate
+    end
   end
 
   get "/non-cacheable" do
@@ -20,11 +24,11 @@ mock_server do
 
   get "/etag" do
     if request.env["HTTP_IF_MODIFIED_SINCE"]
-      halt 301
+      halt 304
     else
       time = Time.now
 
-      response.headers["Etag"] = time.hash.to_s
+      response.headers["ETag"] = time.hash.to_s
       response.headers["Last-Modified"] = time.httpdate
       response.headers["Content-Type"] = "text/plain"
 
@@ -32,7 +36,25 @@ mock_server do
     end
   end
 
-  get "/echo" do
+  get "/changing-etag" do
+    if request.env["HTTP_IF_MODIFIED_SINCE"]
+      time = Time.parse(request.env["HTTP_IF_MODIFIED_SINCE"]) + 1
+    else
+      time = Time.now
+
+      response.headers["ETag"] = time.hash.to_s
+      response.headers["Last-Modified"] = time.httpdate
+      response.headers["Content-Type"] = "text/plain"
+    end
+
+    time.httpdate
+  end
+
+  get "/utf" do
+    "Aló"
+  end
+
+  def route_missing
     request.env.map do |name, value|
       "#{name}: #{value}"
     end.join("\n")
@@ -43,6 +65,26 @@ prepare do
   Redis.current.flushdb
 end
 
+test "handles GET" do
+  _, _, body = Cacho.get("http://localhost:4000")
+
+  assert body["REQUEST_METHOD: GET"]
+end
+
+test "handles OPTIONS" do
+  _, _, body = Cacho.options("http://localhost:4000")
+
+  assert body["REQUEST_METHOD: OPTIONS"]
+end
+
+test "handles HEAD" do
+  status, headers, body = Cacho.head("http://localhost:4000")
+
+  assert status == 200
+  assert headers["Content-Type"]
+  assert body.empty?
+end
+
 test "caches cacheable responses" do
   status, headers, body = Cacho.get("http://localhost:4000/cacheable")
 
@@ -51,6 +93,8 @@ test "caches cacheable responses" do
 
   t1 = body
 
+  sleep 1
+
   status, headers, body = Cacho.get("http://localhost:4000/cacheable")
 
   assert_equal t1, body
@@ -62,6 +106,17 @@ test "caches cacheable responses" do
   assert body > t1
 end
 
+test "varies cache by HTTP method" do
+  status1, _, body1 = Cacho.get("http://localhost:4000/cacheable")
+  sleep 1
+  status2, _, body2 = Cacho.options("http://localhost:4000/cacheable")
+
+  assert status1 == 200
+  assert status2 == 200
+
+  assert body2 > body1
+end
+
 test "does not cache non-cacheable responses" do
   _, _, t1 = Cacho.get("http://localhost:4000/non-cacheable")
   sleep 1
@@ -76,10 +131,22 @@ test "performs conditional GETs" do
   _, _, t2 = Cacho.get("http://localhost:4000/etag")
 
   assert_equal t1, t2
+
+  _, _, t1 = Cacho.get("http://localhost:4000/changing-etag")
+  _, _, t2 = Cacho.get("http://localhost:4000/changing-etag")
+
+  assert t2 > t1
 end
 
 test "allows to pass custom HTTP headers" do
-  _, _, body = Cacho.get("http://localhost:4000/echo", "Accept" => "text/plain")
+  _, _, body = Cacho.get("http://localhost:4000", "Accept" => "text/plain")
+
+  assert body["HTTP_ACCEPT: text/plain"]
+end
+
+test "accepts UTF-encoded bodies" do
+  _, _, body = Cacho.get("http://localhost:4000/utf")
 
-  assert body =~ %r{HTTP_ACCEPT: text/plain}
+  assert body.include?("Aló")
+  assert body.encoding == Encoding::UTF_8
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Damian Janowski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-22 00:00:00 -03:00
+date: 2010-11-26 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency