social-avatar-proxy 1.2.0 → 2.0.0

data/.gitignore

@@ -16,4 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 **.DS_Store
-spec/internal/log/test.log
+spec/internal/log/test.log
+.tmp

data/.travis.yml

@@ -1,3 +1,5 @@
 language: ruby
 rvm:
   - 1.9.3
+services:
+  - memcached

data/README.md

@@ -54,22 +54,55 @@ image_tag(facebook_avatar_path(12345))
 You might wish to configure a default image which will be rendered if an avatar could not be found, or if the remote service has an error (e.g. times out or has a redirect loop), this is simple with an initializer:
 
 ```ruby
-require "social_avatar_proxy/config"
-
 # choose our image
-image_path = Rails.root.join("public", "default_avatar.jpg")
+image_path = Rails.root.join(*%W(app assets images default_avatar.jpg))
 # set the config
-SocialAvatarProxy::Config.default_image = image_path
+SocialAvatarProxy.configure do
+  default_image(image_path)
+end
+```
+
+HTTP caching can be configured as below:
+
+```ruby
+SocialAvatarProxy.configure do
+  http_cache do
+    expires 10.minutes
+    cache_control({
+      max_age: 5.days,
+      max_stale: 1.day,
+      public: true
+    })
+  end
+end
+```
+
+Files can be cached in either or both of Memcached and the file system, here is the configuration options:
+
+```ruby
+SocialAvatarProxy.configure do
+  file_cache do
+    directory "/path/to/folder"
+  end
+  
+  memcache do
+    enable # only required if you don't set either of the following options
+    host "192.168.1.2:11211" # defaults to "localhost:11211"
+    namespace "something:" # defaults to "sap/"
+  end
+end
 ```
 
 ### Rack
 
 The Rack app is available at: SocialAvatarProxy::App.
 
-Both the class and an instance respond to `call` so either can be mounted. The reason for this is that you might wish to set some options first, example:
+Both the class and an instance respond to `call` so either can be mounted.
 
 ```ruby
-use SocialAvatarProxy::App.new(cache_control: false)
+use SocialAvatarProxy::App
+# or
+use SocialAvatarProxy::App.new
 ```
 
 ## Contributing

data/lib/social_avatar_proxy/app.rb

@@ -2,33 +2,23 @@ require "social_avatar_proxy/config"
 require "social_avatar_proxy/facebook_avatar"
 require "social_avatar_proxy/twitter_avatar"
 require "social_avatar_proxy/routes"
+require "social_avatar_proxy/response"
 require "social_avatar_proxy/timeout_error"
 require "social_avatar_proxy/too_many_redirects_error"
 require "rack"
 
 module SocialAvatarProxy
   class App
-    def self.call(env, options = {})
-      new(options).call(env)
+    def self.call(env)
+      new.call(env)
     end
     
-    def self.routes(options = {})
-      new(options).routes
+    def self.routes
+      new.routes
     end
     
     attr_reader :options, :request
     
-    def initialize(options = {})
-      @options = {
-        expires: 86400, # 1 day from now
-        cache_control: {
-          max_age: 86400, # store for 1 day, after that re-request
-          max_stale: 86400, # allow cache to be a day stale
-          public: true # allow proxy caching
-        }
-      }.merge(options)
-    end
-    
     def call(env)
       @request = Rack::Request.new(env)
       begin
@@ -41,7 +31,7 @@ module SocialAvatarProxy
     end
     
     def path_prefix
-      (options[:path_prefix] || (request && request.env["SCRIPT_NAME"]) || "").gsub(/\/$/, "")
+      ((request && request.env["SCRIPT_NAME"]) || "").gsub(/\/$/, "")
     end
     
     def response
@@ -49,60 +39,11 @@ module SocialAvatarProxy
       unless request.path =~ /^#{path_prefix}\/(facebook|twitter)\/([\w\-\.]+)(\.(jpe?g|png|gif|bmp))?$/i
         return not_found
       end
-      # load the avatar
-      avatar = load_avatar($1, $2)
-      # if it exists
-      if avatar.exist?
-        # render the avatar to the response
-        Rack::Response.new do |response|
-          # set the response data
-          response.write(avatar.body)
-          # set the response headers
-          response = set_avatar_headers(response, avatar)
-          response = set_caching_headers(response)
-          # return the response
-          response
-        end
-      # if the avatar doesn't exist
-      else
-        not_found
-      end
-    end
-    
-    def not_found
-      Rack::Response.new([], 404) do |response|
-        # if we have a custom default image
-        if Config.default_image
-          render_default_image(response)
-        # without a default image
-        else
-          response.write "Not Found"
-        end
-      end
-    end
-    
-    def timeout
-      Rack::Response.new([], 504) do |response|
-        # if we have a custom default image
-        if Config.default_image
-          render_default_image(response)
-        # without a default image
-        else
-          response.write "Remote server timeout"
-        end
-      end
-    end
-    
-    def bad_gateway
-      Rack::Response.new([], 502) do |response|
-        # if we have a custom default image
-        if Config.default_image
-          render_default_image(response)
-        # without a default image
-        else
-          response.write "Bad response from remote server"
-        end
-      end
+      # create our response
+      SocialAvatarProxy::Response.build({
+        service: $1,
+        identifier: $2
+      })
     end
     
     def routes
@@ -110,51 +51,16 @@ module SocialAvatarProxy
     end
     
     private
-    def render_default_image(response)
-      # render the image
-      response.write(Config.default_image_data)
-      # set the content type
-      response["Content-Type"] = Config.default_image_content_type
-      # set expiry
-      response = set_caching_headers(response)
-      # return the response
-      response
-    end
-  
-    def set_avatar_headers(response, avatar)
-      # set the last modified header
-      response["Last-Modified"] = avatar.last_modified
-      # set the content type header
-      response["Content-Type"] = avatar.content_type
-      # return the response
-      response
+    def not_found
+      Rack::Response.new("Not Found", 404)
     end
     
-    def set_caching_headers(response)
-      # if we want to expire in a set time, calculate the header
-      if options[:expires]
-        response["Expires"] = (Time.now + options[:expires]).httpdate
-      end
-      # if we want to set cache control settings
-      if cc = options[:cache_control]
-        directives = []
-        directives << "no-cache" if cc[:no_cache]
-        directives << "max-stale=#{cc[:max_stale]}" if cc[:max_stale]
-        directives << "max-age=#{cc[:max_age]}" if cc[:max_age]
-        directives << (cc[:public] ? "public" : "private")
-        response["Cache-Control"] = directives.join(", ")
-      end
-      # return the response
-      response
+    def timeout
+      Rack::Response.new("Gateway Timeout", 504)
     end
     
-    def load_avatar(service, id)
-      # titleize the service name
-      service = service.gsub(/[\_\-]/, " ").gsub(/\b([a-z])/) do |match|
-        match.upcase
-      end
-      # pass it onto the
-      SocialAvatarProxy.const_get("#{service}Avatar").new(id)
+    def bad_gateway
+      Rack::Response.new("Bad Gateway: Too many redirects", 502)
     end
   end
 end

data/lib/social_avatar_proxy/avatar.rb

@@ -1,4 +1,5 @@
 require "social_avatar_proxy/remote_file_resolver"
+require "social_avatar_proxy/avatar_file"
 
 module SocialAvatarProxy
   class Avatar
@@ -39,16 +40,26 @@ module SocialAvatarProxy
       end
     end
     
-    # returns whether the avatar has changed
-    def modified_since?(timestamp)
-      last_modified > timestamp
-    end
-    
     # in the base Avatar class, we'll use the identifier as the URL
     def remote_url
       identifier
     end
     
+    # return a temporary file object
+    def file
+      AvatarFile.new(File.basename(remote_url)).tap do |file|
+        begin
+          file.write(body)
+          file.content_type(content_type)
+          file.mtime(last_modified)
+          file.rewind
+        rescue
+          file.close
+          raise
+        end
+      end if exist?
+    end
+    
     private    
     # request the remote file
     def response

data/lib/social_avatar_proxy/avatar_file.rb

@@ -0,0 +1,27 @@
+require "tempfile"
+require "fileutils"
+require "delegate"
+
+module SocialAvatarProxy
+  class AvatarFile < SimpleDelegator
+    attr_reader :file
+
+    def initialize(path)
+      if File.exist?(path)
+        @file = File.new(path)
+        mtime(file.mtime)
+      else
+        @file = Tempfile.new(path.gsub("/", "-"))
+      end
+      super(file)
+    end
+
+    def mtime(value = nil)
+      value ? @mtime = value.to_i : Time.at(@mtime)
+    end
+
+    def content_type(value = nil)
+      value ? @content_type = value : @content_type
+    end
+  end
+end

data/lib/social_avatar_proxy/config.rb

@@ -1,30 +1,9 @@
+require "social_avatar_proxy/configuration"
+
 module SocialAvatarProxy
-  class Config
-    class << self
-      attr_accessor :default_image
-      
-      def default_image_file
-        default_image && File.new(default_image)
-      end
-      
-      def default_image_data
-        default_image_file.read
-      end
-      
-      def default_image_content_type
-        case File.extname(default_image).downcase
-        when /^\.jpe?g$/
-          "image/jpeg"
-        when /^\.png$/
-          "image/png"
-        when /^\.gif$/
-          "image/gif"
-        when /^\.svg$/
-          "image/svg+xml"
-        else
-          "application/octet-stream"
-        end
-      end
-    end
+  Config = Configuration.new
+  
+  def self.configure(&block)
+    Config.configure(&block)
   end
 end

data/lib/social_avatar_proxy/configuration/cache.rb

@@ -0,0 +1,57 @@
+module SocialAvatarProxy
+  class Configuration
+    class Cache
+      def read(options = {})
+        false
+      end
+      
+      def write(file, options = {})
+        file
+      end
+      
+      def fetch(options = {}, &block)
+        # if the cache is enabled attempt read
+        file = attempt_read(options)
+        # if read fails yield the block
+        # if the cache is enabled attempt write
+        # return the block result
+        unless file
+          file = block.yield
+          attempt_write(file, options) if file
+        end
+        # return the file
+        file
+      end
+      
+      def configure(&block)
+        enable
+        instance_eval(&block)
+      end
+      
+      def disabled?
+        !enabled?
+      end
+
+      def enabled?
+        !!@enabled
+      end
+      
+      private
+      def disable
+        @enabled = false
+      end
+      
+      def enable
+        @enabled = true
+      end
+      
+      def attempt_read(options = {})
+        enabled? && read(options)
+      end
+      
+      def attempt_write(file, options = {})
+        enabled? && write(file, options)
+      end
+    end
+  end
+end

data/lib/social_avatar_proxy/configuration/caches.rb

@@ -0,0 +1,15 @@
+module SocialAvatarProxy
+  class Configuration
+    class Caches < Array
+      def fetch(*args, &block)
+        if cache = delete_at(0)
+          cache.fetch(*args) do
+            fetch(*args, &block)
+          end
+        else
+          block.yield
+        end
+      end
+    end
+  end
+end

data/lib/social_avatar_proxy/configuration/file_cache.rb

@@ -0,0 +1,46 @@
+require "social_avatar_proxy/avatar_file"
+require "social_avatar_proxy/configuration/cache"
+require "digest/md5"
+require "fileutils"
+
+module SocialAvatarProxy
+  class Configuration
+    class FileCache < Cache
+      def read(options = {})
+        path = generate_key(options)
+        # ensure the file exists and it's readable
+        unless File.exist?(path) && File.readable?(path)
+          return false
+        end
+        # return the file
+        AvatarFile.new(path).tap do |file|
+          file.mtime(File.mtime(path))
+        end
+      end
+      
+      def write(file, options = {})
+        # generate the file location
+        path = generate_key(options)
+        # create the folder
+        FileUtils.mkdir_p File.dirname(path)
+        # write the file
+        File.open(path, "wb") do |f|
+          f.write(file.read)
+        end
+      end
+      
+      private
+      def generate_key(options = {})
+        # generate a hash for the filename
+        hash = "#{options[:service]}-#{options[:identifier]}"
+        name = "sap-#{Digest::MD5.hexdigest(hash)}"
+        File.join(@directory, name)
+      end
+      
+      # set the directory
+      def directory(value)
+        @directory = value
+      end
+    end
+  end
+end

data/lib/social_avatar_proxy/configuration/http_cache.rb

@@ -0,0 +1,55 @@
+module SocialAvatarProxy
+  class Configuration
+    class HttpCache
+      def configure(&block)
+        @enabled = true
+        instance_eval(&block)
+      end
+
+      def apply_caching_headers(response)
+        # if we want to expire in a set time, calculate the header
+        if expires
+          response["Expires"] = (Time.now + expires.to_i).httpdate
+        end
+        # if we want to set cache control settings
+        if cc = cache_control
+          directives = []
+          directives << "no-cache" if cc[:no_cache]
+          directives << "max-stale=#{cc[:max_stale]}" if cc[:max_stale]
+          directives << "max-age=#{cc[:max_age]}" if cc[:max_age]
+          directives << (cc[:public] ? "public" : "private")
+          response["Cache-Control"] = directives.join(", ")
+        end
+        # return the response
+        response
+      end
+
+      def disabled?
+        !enabled?
+      end
+
+      def enabled?
+        !!@enabled
+      end
+
+      private
+      def cache_control(value = nil)
+        if value
+          @cache_control = value
+        end
+        @cache_control
+      end
+
+      def expires(value = nil)
+        if value
+          @expires = value
+        end
+        @expires
+      end
+      
+      def disable
+        @enabled = false
+      end
+    end
+  end
+end

data/lib/social_avatar_proxy/configuration/memcache.rb

@@ -0,0 +1,97 @@
+require "social_avatar_proxy/avatar_file"
+require "social_avatar_proxy/configuration/cache"
+require "dalli"
+require "digest/md5"
+
+module SocialAvatarProxy
+  class Configuration
+    class Memcache < Cache
+      def read(options = {})
+        # generate the key
+        file_key = generate_key(options)
+        # if the key exists, serve the data
+        if data = connection.get(file_key)
+          content_type = connection.get("#{file_key}-content-type") || "image/jpeg"
+          mtime = connection.get("#{file_key}-mtime") || Time.now
+          # serve the avatar file
+          AvatarFile.new(file_key).tap do |file|
+            begin
+              file.write(data)
+              file.content_type(content_type)
+              file.mtime(mtime)
+              file.rewind
+            rescue
+              file.close
+              file.unlink
+              raise
+            end
+          end
+        end
+      end
+
+      def write(file, options = {})
+        # generate the file location
+        file_key = generate_key(options)
+        # write the file
+        connection.set(file_key, file.read)
+        # if the file has a content type
+        if file.respond_to?(:content_type) && file.content_type
+          # write the content type
+          connection.set("#{file_key}-content-type", file.content_type)
+        end
+        # if the file has a modified time
+        if file.respond_to?(:mtime) && file.mtime
+          # write the content type
+          connection.set("#{file_key}-mtime", file.mtime.to_i)
+        end
+      end
+
+      def initialize
+        key do |options|
+          pre_hash = "#{options[:service]}-#{options[:identifier]}"
+          "#{@namespace || "sap/"}#{Digest::MD5.hexdigest(pre_hash)}"
+        end
+      end
+
+      private
+      # set which Memcached server to use
+      # default: "localhost:11211"
+      def host(value)
+        @host = value
+      end
+      
+      # set the key namespace
+      # default: "sap/"
+      def namespace(value)
+        @namespace = value
+      end
+      
+      # set the key generation block
+      # should accept a hash of options
+      def key(&block)
+        @key = block
+      end
+
+      # generate a key given the arguments
+      def generate_key(*args)
+        @key.yield(*args)
+      end
+      
+      # return a connection to Memcache
+      # defaults to a Dalli::Client object
+      def connection(value = nil)
+        if value
+          unless value.respond_to?(:get) && value.respond_to?(:set)
+            raise ArgumentError, %Q(
+              #{value.inspect}
+              must respond to #set and #get
+              when using as a Memcache connection
+            )
+          end
+          @connection = value
+        end
+        @connection ||= Dalli::Client.new(@host || "localhost:11211")
+      end
+    end
+  end
+end

data/lib/social_avatar_proxy/configuration.rb

@@ -0,0 +1,112 @@
+require "social_avatar_proxy/configuration/file_cache"
+require "social_avatar_proxy/configuration/http_cache"
+require "social_avatar_proxy/configuration/memcache"
+require "social_avatar_proxy/configuration/caches"
+require "social_avatar_proxy/avatar_file"
+
+module SocialAvatarProxy
+  class Configuration
+    def initialize
+      @memcache = Memcache.new
+      @file_cache = FileCache.new
+      @http_cache = HttpCache.new
+    end
+    
+    # updates the configuration
+    def configure(&block)
+      instance_eval(&block)
+    end
+
+    # configures or retrieves the file cache instance
+    def file_cache(&block)
+      if block_given?
+        @file_cache.configure(&block)
+      else
+        @file_cache
+      end
+    end
+
+    # configures or retrieves the http cache instance
+    def http_cache(&block)
+      if block_given?
+        @http_cache.configure(&block)
+      else
+        @http_cache
+      end
+    end
+    
+    # configures or retrieves the memcache cache instance
+    def memcache(&block)
+      if block_given?
+        @memcache.configure(&block)
+      else
+        @memcache
+      end
+    end
+    
+    # serves the file via a header
+    def x_send_file
+      serve_via(:x_send_file)
+    end
+    
+    # serves the file via an x_accel_redirect
+    def x_accel_redirect
+      serve_via(:x_accel_redirect)
+    end
+    
+    # returns how the app should serve the file
+    # defaults to streaming the file data
+    def delivery_method
+      @serve_via ||= :stream
+    end
+    
+    # returns a Caches object containing the configured caches
+    def caches
+      Caches.new.tap do |set|
+        set.push(@memcache) if @memcache.enabled?
+        set.push(@file_cache) if @file_cache.enabled?
+      end
+    end
+    
+    def default_image(value = nil)
+      if value
+        unless File.exist?(value) && File.readable?(value)
+          raise ArgumentError, "#{value} does not exist, or is unreadable"
+        end
+        @default_image = value
+      end
+      @default_image && AvatarFile.new(@default_image).tap do |file|
+        file.content_type(default_image_content_type)
+      end
+    end
+    
+    def default_image_content_type(value = nil)
+      @default_image_content_type = value if value
+      [
+        @default_image_content_type,
+        auto_detect_default_image_content_type,
+        "application/octet-stream"
+      ].compact.first
+    end
+    
+    private
+    def serve_via(value)
+      @serve_via = value
+    end
+    
+    def auto_detect_default_image_content_type
+      case File.extname(@default_image)
+      when ".png"
+        "image/png"
+      when ".gif"
+        "image/gif"
+      when ".svg"
+        "application/svg+xml"
+      when /\.jpe?g/
+        "image/jpeg"
+      else
+        "application/octet-stream"
+      end if @default_image
+    end
+  end
+end

data/lib/social_avatar_proxy/response.rb

@@ -0,0 +1,90 @@
+require "social_avatar_proxy/config"
+require "rack"
+
+module SocialAvatarProxy
+  class Response < Rack::Response
+    def self.build(options = {})
+      # build the response
+      response = ResponseBuilder.new(options).response
+      # apply the HTTP caching to the response
+      SocialAvatarProxy::Config.http_cache.apply_caching_headers(response)
+    end
+  end
+  
+  class ResponseBuilder
+    attr_reader :service, :identifier
+    
+    def initialize(options)
+      @service = options.fetch(:service)
+      @identifier = options.fetch(:identifier)
+    end
+    
+    def response
+      return @response if defined?(@response)
+      if file
+        @response = Response.new do |response|
+          write_file(response)
+          set_file_headers(response)
+        end
+      else
+        @response = Rack::Response.new("Not Found", 404)
+      end
+    end
+    
+    def set_file_headers(response)
+      # set the modified time
+      if file.respond_to?(:mtime) && file.mtime
+        response["Last-Modified"] = file.mtime.httpdate
+      end
+      # set the content type
+      if file.respond_to?(:content_type) && file.content_type
+        response["Content-Type"] = file.content_type
+      end
+    end
+    
+    def write_file(response)
+      # configure the file delivery
+      case Config.delivery_method
+      when :x_accel_redirect
+        # set the NGINX header
+        response["X-Accel-Redirect"] = file.path
+      when :x_send_file
+        # set the Apache header
+        response["X-Sendfile"] = file.path
+      else
+        begin
+          # read the file contents
+          data = file.read
+          # write it to the response
+          response.write(data)
+        ensure
+          # close the file
+          file.close
+        end
+      end
+    end
+    
+    def file
+      @file ||= SocialAvatarProxy::Config.caches.fetch({
+        service: service,
+        identifier: identifier
+      }) do
+        remote_avatar_file || default_image
+      end
+    end
+    
+    private
+    def default_image
+      SocialAvatarProxy::Config.default_image
+    end
+    
+    def remote_avatar_file
+      # titleize the service name
+      service_name = service.gsub(/[\_\-]/, " ").gsub(/\b([a-z])/) do |match|
+        match.upcase
+      end
+      # pass it onto the service, and retrieve the file
+      SocialAvatarProxy.const_get("#{service_name}Avatar").new(identifier).file
+    end
+  end
+end

data/lib/social_avatar_proxy/version.rb

@@ -1,3 +1,3 @@
 module SocialAvatarProxy
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
 end

data/lib/social_avatar_proxy.rb

@@ -4,6 +4,7 @@ require "social_avatar_proxy/app"
 require "social_avatar_proxy/avatar"
 require "social_avatar_proxy/facebook_avatar"
 require "social_avatar_proxy/twitter_avatar"
+require "social_avatar_proxy/config"
 
 if defined?(Rails) && defined?(Rails::Engine)
   require "social_avatar_proxy/engine"

data/social-avatar-proxy.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   
   s.add_dependency "rack"
+  s.add_dependency "dalli"
 
   s.add_development_dependency "combustion"
   s.add_development_dependency "rake"

data/spec/social_avatar_proxy/app_spec.rb

@@ -6,9 +6,7 @@ describe SocialAvatarProxy::App do
     Rack::MockRequest.new(app)
   end
   
-  let(:app) { SocialAvatarProxy::App.new(options) }
-
-  let(:options) { Hash.new }
+  let(:app) { SocialAvatarProxy::App.new }
   
   let(:successful_response) do
     response = Net::HTTPSuccess.new("1.1", 200, "Success")
@@ -23,7 +21,13 @@ describe SocialAvatarProxy::App do
   
   let(:response) { nil }
   
+  let(:image_path) do
+    File.join(File.dirname(__FILE__), "../fixtures/image.jpg")
+  end
+  
   before(:each) do
+    SocialAvatarProxy.send(:remove_const, :Config)
+    SocialAvatarProxy.const_set(:Config, SocialAvatarProxy::Configuration.new)
     klass = SocialAvatarProxy::Avatar
     klass.any_instance.stub(:response).and_return(response)
   end
@@ -41,9 +45,8 @@ describe SocialAvatarProxy::App do
     subject { SocialAvatarProxy::App }
     
     it "should return a object providing the path helpers" do
-      options = { path_prefix: "/test" }
-      expect(subject.routes(options).facebook_avatar_path("ryandtownsend")).to match(/^\/.*$/)
-      expect(subject.routes(options).twitter_avatar_path(2202971)).to match(/^\/.*$/)
+      expect(subject.routes.facebook_avatar_path("ryandtownsend")).to match(/^\/.*$/)
+      expect(subject.routes.twitter_avatar_path(2202971)).to match(/^\/.*$/)
     end
   end
   
@@ -62,17 +65,6 @@ describe SocialAvatarProxy::App do
     it "should return a 404 response" do
       expect(subject.get(path).status).to eq(404)
     end
-    
-    context "with a custom image" do
-      before(:each) do
-        image_path = File.join(File.dirname(__FILE__), "../fixtures/image.jpg")
-        SocialAvatarProxy::Config.default_image = image_path
-      end
-      
-      it "should render the image" do
-        expect(subject.get(path)["Content-Type"]).to eq("image/jpeg")
-      end
-    end
   end
   
   context "given a valid path" do
@@ -104,17 +96,76 @@ describe SocialAvatarProxy::App do
         expect(subject.get(path).status).to eq(200)
       end
       
-      it "should return a Cache-Control header by default" do
-        expect(subject.get(path).headers["Cache-Control"]).to eq("max-stale=86400, max-age=86400, public")
+      context "with memcache in place" do
+        before(:each) do
+          SocialAvatarProxy.configure do
+            memcache do
+              enable
+            end
+          end
+        end
+        
+        it "should attempt to get the image from the cache" do
+          expect(subject.get(path).status).to eq(200)
+        end
+      end
+      
+      context "with file cache in place" do
+        before(:each) do
+          SocialAvatarProxy.configure do
+            file_cache do
+              directory File.join(File.dirname(__FILE__), "../../.tmp")
+            end
+          end
+        end
+        
+        it "should attempt to get the image from the cache" do
+          expect(subject.get(path).status).to eq(200)
+        end
+      end
+      
+      context "with memcache and the file cache in place" do
+        before(:each) do
+          SocialAvatarProxy.configure do
+            memcache do
+              enable
+            end
+            file_cache do
+              directory File.join(File.dirname(__FILE__), "../../.tmp")
+            end
+          end
+        end
+        
+        it "should attempt to get the image from the cache" do
+          expect(subject.get(path).status).to eq(200)
+        end
       end
       
-      it "should return a Expires header by default" do
-        expect(subject.get(path).headers["Expires"]).to eq((Time.now + 86400).httpdate)
+      context "with Cache-Control set with Max-Age and Max-Stale as 1 day" do
+        before(:each) do
+          SocialAvatarProxy.configure do
+            http_cache do
+              cache_control({
+                max_stale: 86400,
+                max_age: 86400,
+                public: true
+              })
+            end
+          end
+        end
+        
+        it "should return a Cache-Control header" do
+          expect(subject.get(path).headers["Cache-Control"]).to eq("max-stale=86400, max-age=86400, public")
+        end
       end
       
       context "given Cache-Control is turned off" do
-        let(:options) do
-          { cache_control: false }
+        before(:each) do
+          SocialAvatarProxy.configure do
+            http_cache do
+              disable
+            end
+          end
         end
         
         it "should not return a Cache-Control header" do
@@ -123,8 +174,12 @@ describe SocialAvatarProxy::App do
       end
       
       context "given Cache-Control is set to private" do
-        let(:options) do
-          { cache_control: { public: false } }
+        before(:each) do
+          SocialAvatarProxy.configure do
+            http_cache do
+              cache_control({ public: false })
+            end
+          end
         end
         
         it "should return a Cache-Control header marked for private use" do
@@ -133,8 +188,12 @@ describe SocialAvatarProxy::App do
       end
       
       context "given Expires is turned off" do
-        let(:options) do
-          { expires: false }
+        before(:each) do
+          SocialAvatarProxy.configure do
+            http_cache do
+              cache_control({ expires: false })
+            end
+          end
         end
         
         it "should not return a Cache-Control header" do
@@ -143,8 +202,12 @@ describe SocialAvatarProxy::App do
       end
       
       context "given Expires is set to two days" do
-        let(:options) do
-          { expires: (86400 * 2) }
+        before(:each) do
+          SocialAvatarProxy.configure do
+            http_cache do
+              expires 86400 * 2
+            end
+          end
         end
         
         it "should not return a Cache-Control header" do
@@ -155,11 +218,24 @@ describe SocialAvatarProxy::App do
     
     context "that fails to find an avatar" do
       let(:response) { not_found_response }
+      let(:path) { "/facebook/someRandomUserThatDoesntExist" }
 
       it "should return a 404 response" do
-        path = "/facebook/someRandomUserThatDoesntExist"
         expect(subject.get(path).status).to eq(404)
       end
+      
+      context "with a custom image" do
+        before(:each) do
+          ip = image_path
+          SocialAvatarProxy.configure do
+            default_image(ip)
+          end
+        end
+        
+        it "should render the image" do
+          expect(subject.get(path)["Content-Type"]).to eq("image/jpeg")
+        end
+      end
     end
   end
 end

data/spec/social_avatar_proxy/avatar_spec.rb

@@ -72,20 +72,6 @@ describe SocialAvatarProxy::Avatar do
           expect(subject.last_modified.to_i).to eq(timestamp.to_i)
         end
       end
-      
-      describe "#modified_since?" do
-        context "given a date older than the timestamp" do
-          it "should return true" do
-            expect(subject.modified_since?(timestamp - 86400)).to be_true
-          end
-        end
-        
-        context "given a date newer than the timestamp" do
-          it "should return true" do
-            expect(subject.modified_since?(Time.now)).to be_false
-          end
-        end
-      end
     end
     
     context "with no last-modified header" do

data/spec/social_avatar_proxy/config_spec.rb

@@ -3,8 +3,13 @@ require "spec_helper"
 describe SocialAvatarProxy::Config do
   subject { SocialAvatarProxy::Config }
   
-  after(:each) do
-    subject.default_image = nil
+  around(:each) do
+    SocialAvatarProxy.send(:remove_const, :Config)
+    SocialAvatarProxy.const_set(:Config, SocialAvatarProxy::Configuration.new)
+  end
+  
+  let(:image_path) do
+    File.join(File.dirname(__FILE__), "../fixtures/image.jpg")
   end
 
   describe "::default_image" do
@@ -13,45 +18,43 @@ describe SocialAvatarProxy::Config do
     end
 
     it "should store a path" do
-      subject.default_image = "/test.jpg"
-      expect(subject.default_image).to eq "/test.jpg"
+      subject.configure do
+        default_image(image_path)
+      end
+      expect(subject.default_image.path).to eq(image_path)
     end
   end
   
   describe "::default_image_content_type" do
-    context "with a JPEG" do
-      it "should return image/jpeg" do
-        subject.default_image = "/test.JPG"
-        expect(subject.default_image_content_type).to eq "image/jpeg"
-      end
+    it "should default to nil" do
+      expect(subject.default_image_content_type).to be_nil
     end
     
-    context "with a PNG" do
-      it "should return image/png" do
-        subject.default_image = "/test.png"
-        expect(subject.default_image_content_type).to eq "image/png"
+    context "with an overridden content type" do
+      it "should return the value set" do
+        subject.configure do
+          default_image(image_path)
+          default_image_content_type("something/banana")
+        end
+        expect(subject.default_image_content_type).to eq("something/banana")
       end
     end
-    
-    context "with a GIF" do
-      it "should return image/gif" do
-        subject.default_image = "/test.gif"
-        expect(subject.default_image_content_type).to eq "image/gif"
+  
+    context "with a default_image set" do
+      before(:each) do
+        subject.configure do
+          default_image(image_path)
+        end
       end
-    end
     
-    context "with a SVG" do
-      it "should return image/svg+xml" do
-        subject.default_image = "/test.svg"
-        expect(subject.default_image_content_type).to eq "image/svg+xml"
+      it "should return the calculated content type" do
+        expect(subject.default_image_content_type).to eq("image/jpeg")
       end
-    end
     
-    context "with an unknown type" do
-      it "should return application/octet-stream" do
-        subject.default_image = "/test"
-        expect(subject.default_image_content_type).to eq "application/octet-stream"
+      it "should set the content type on the image" do
+        expect(subject.default_image.content_type).to eq("image/jpeg")
       end
     end
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: social-avatar-proxy
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-09 00:00:00.000000000 Z
+date: 2012-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -126,11 +142,19 @@ files:
 - lib/social_avatar_proxy.rb
 - lib/social_avatar_proxy/app.rb
 - lib/social_avatar_proxy/avatar.rb
+- lib/social_avatar_proxy/avatar_file.rb
 - lib/social_avatar_proxy/config.rb
+- lib/social_avatar_proxy/configuration.rb
+- lib/social_avatar_proxy/configuration/cache.rb
+- lib/social_avatar_proxy/configuration/caches.rb
+- lib/social_avatar_proxy/configuration/file_cache.rb
+- lib/social_avatar_proxy/configuration/http_cache.rb
+- lib/social_avatar_proxy/configuration/memcache.rb
 - lib/social_avatar_proxy/engine.rb
 - lib/social_avatar_proxy/facebook_avatar.rb
 - lib/social_avatar_proxy/path_helpers.rb
 - lib/social_avatar_proxy/remote_file_resolver.rb
+- lib/social_avatar_proxy/response.rb
 - lib/social_avatar_proxy/routes.rb
 - lib/social_avatar_proxy/timeout_error.rb
 - lib/social_avatar_proxy/too_many_redirects_error.rb
@@ -163,15 +187,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -284777560749383164
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -284777560749383164
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: This gem acts as a proxy for avatars on Twitter & Facebook.