rack-mogilefs 0.2.0 → 0.3.0

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+/coverage

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    rack-mogilefs (0.3.0)
+      mogilefs-client (~> 2.1.0)
+      rack (~> 1.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mocha (0.9.8)
+      rake
+    mogilefs-client (2.1.0)
+    rack (1.1.0)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  mogilefs-client (~> 2.1.0)
+  rack (~> 1.1.0)
+  rack-mogilefs!

data/HISTORY.md

@@ -1,3 +1,11 @@
+## 0.3.0 (2010-12-30)
+
+* Major refactoring of internals
+* Codebase is now more modular, easier to extend and customize
+* Add support for Cache-Control header
+* Add debug flag to turn off built-in exception handling and make bugs easier
+  to find
+
 ## 0.2.0 (2010-11-29)
 
 * Add X-Reproxy-Url support

data/README.md

@@ -4,33 +4,6 @@ If you are using Nginx you'll probably want to serve MogileFS files with
 the [MogileFS Module](http://www.grid.net.ru/nginx/mogilefs.en.html), but if
 you need a quick way to serve them out of a Rack app, this should help.
 
-## Caveats ( serving files vs reproxying )
-
-Serving files through Ruby is slow. The preferred method is to set an
-X-Reproxy-Url header from your app and let the web server serve the file. For
-Nginx, you could have a config like this:
-
-    location /reproxy {
-        internal;
-        set $reproxy $upstream_http_x_reproxy_url;
-        proxy_pass $reproxy;
-        proxy_hide_header Content-Type;
-    }
-
-For Apache, there is [mod_reproxy](http://github.com/jamis/mod_reproxy)
-
-`Rack::MogileFS` will use this method if you pass a strategy option of `:reproxy`
-
-    use Rack::MogileFS, :strategy => :reproxy
-
-`Rack::MogileFS` will look up the internal urls for the file, and set two
-headers to reproxy the request:
-
-    X-Accel-Redirect: /reproxy
-    X-Reproxy-Url: http://internal.ip/path/to/mogile/file.fid
-
-You'll have to make sure your web server knows how to handle this request.
-
 ## Getting Started:
 
 First install the gem:
@@ -39,10 +12,6 @@ First install the gem:
 
 There are a variety of ways to use it:
 
-### Rack middleware
-    # (config.ru)
-    use Rack::MogileFS, :path => %r{^/assets/*}
-
 ### Rails 3:
 
     # (config/routes.rb)
@@ -61,6 +30,10 @@ There are a variety of ways to use it:
       end
     end
 
+### Rack middleware
+    # (config.ru)
+    use Rack::MogileFS, :path => %r{^/assets/*}
+
 ## File Lookup
 
 `Rack::MogileFS` uses the request path (`PATH_INFO`) for the MogileFS key. The
@@ -100,3 +73,35 @@ and initialize a MogileFS client like this:
 You can override this by passing in a MogileFS client of your own:
 
     Rack::MogileFS::Endpoint.new :client => MyMogileFSClient.new
+
+## Caveats ( serving files vs reproxying )
+
+Serving files through Ruby can be slow. `Rack::MogileFS` will read the entire
+file into memory before sending it downstream. If you have varnish/squid/a CDN
+sitting in front of rails then this isn't so problematic.
+
+The preferred method is to set an X-Reproxy-Url header from your app and let
+the web server serve the file instead of `Rack::MogileFS`. For Nginx, you
+could have a config like this:
+
+    location /reproxy {
+        internal;
+        set $reproxy $upstream_http_x_reproxy_url;
+        proxy_pass $reproxy;
+        proxy_hide_header Content-Type;
+    }
+
+For Apache, there is [mod_reproxy](http://github.com/jamis/mod_reproxy)
+
+`Rack::MogileFS` will use this method if you pass a strategy option of `:reproxy`
+
+    use Rack::MogileFS, :strategy => :reproxy
+
+`Rack::MogileFS` will look up the internal urls for the file, and set two
+headers to reproxy the request:
+
+    X-Accel-Redirect: /reproxy
+    X-Reproxy-Url: http://internal.ip/path/to/mogile/file.fid
+
+You'll have to make sure your web server knows how to handle this request.
+

data/Rakefile

@@ -1,3 +1,6 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
 require 'rake/clean'
 require 'rake/testtask'
 
@@ -17,4 +20,4 @@ task :coverage do
   rm_f "coverage.data"
   system "rcov -x /Users -Ilib:test test/*_test.rb"
   system "open coverage/index.html" if PLATFORM['darwin']
-end
+end

data/lib/rack/mogilefs.rb

@@ -5,6 +5,7 @@ require 'rack/utils'
 module Rack
   class MogileFS
     autoload :Endpoint, "rack/mogilefs/endpoint"
+    autoload :Version, "rack/mogilefs/version"
 
     def initialize(app, options={})
       @app, @options = app, options

data/lib/rack/mogilefs/endpoint.rb

@@ -1,82 +1,40 @@
+require 'rack/mogilefs/endpoint/base'
+require 'rack/mogilefs/endpoint/caching'
+require 'rack/mogilefs/endpoint/client'
+require 'rack/mogilefs/endpoint/mapper'
+require 'rack/mogilefs/endpoint/reproxy'
+require 'rack/mogilefs/endpoint/rescues'
+
 module Rack
   class MogileFS
     class Endpoint
 
-      def initialize(options={})
-        @options = {
-          :client   => nil,
-          :mapper   => nil,
-          :strategy => :serve,
-          :default_content_type => "image/png"
-        }.merge(options)
-
-        @options[:client] ||= default_client
-      end
-
-      def call(env)
-        path = key_for_path(env['PATH_INFO'].dup)
+      class File
+        attr_accessor :path, :data
 
-        if @options[:strategy] == :reproxy
-          reproxy(path)
-        else
-          serve_file(path)
+        def initialize(path, data)
+          @path, @data = path, data
         end
 
-      rescue ::MogileFS::Backend::UnknownKeyError => e
-        [ 404, { "Content-Type" => "text/html" }, [e.message] ]
-      rescue ::MogileFS::UnreachableBackendError => e
-        [ 503, { "Content-Type" => "text/html" }, [e.message] ]
-      rescue ::MogileFS::Error => e
-        [ 500, { "Content-Type" => "text/html" }, [e.message] ]
-      end
-
-      protected
-
-      def reproxy(path)
-        paths = client.get_paths(path)
-
-        [ 200, {
-          "Content-Type"     => content_type(path),
-          "X-Accel-Redirect" => "/reproxy",
-          "X-Reproxy-Url"    => paths.join(" ")
-        }, [] ]
-      end
-
-      def serve_file(path)
-        data = client.get_file_data(path)
-        size = Utils.bytesize(data).to_s
-
-        [ 200, {
-          "Content-Type"   => content_type(path),
-          "Content-Length" => size
-        }, [data] ]
-      end
-
-      def key_for_path(path)
-        @options[:mapper].respond_to?(:call) ? @options[:mapper].call(path) : path
-      end
-
-      def content_type(path)
-        Mime.mime_type(::File.extname(path), @options[:default_content_type])
-      end
-
-      def client
-        @options[:client]
-      end
+        def extname
+          ::File.extname(@path)
+        end
 
-      def default_client
-        ::MogileFS::MogileFS.new(config)
-      end
+        def length
+          Utils.bytesize(@data).to_s
+        end
 
-      def config
-        if defined?(Rails)
-          yml = YAML.load_file( Rails.root.join("config/mogilefs.yml") )
-          yml[Rails.env]["connection"].symbolize_keys
-        else
-          { :domain => "default", :hosts => ["127.0.0.1:7001"] }
+        def content_type(default=nil)
+          Mime.mime_type(extname, default)
         end
       end
 
+      include Base
+      include Client
+      include Caching
+      include Mapper
+      include Reproxy
+      include Rescues
     end
   end
 end

data/lib/rack/mogilefs/endpoint/base.rb

@@ -0,0 +1,47 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # This contains the base functionality for serving a MogileFS file. Most
+      # of the useful stuff is layered on top the base class in other modules
+      module Base
+        def initialize(options={})
+          @options = {
+            :default_content_type => "image/png"
+          }.merge(options)
+        end
+
+        def call(env)
+          path = key_for_path( env['PATH_INFO'].dup )
+          serve_file(path)
+        end
+
+        protected
+
+        def serve_file(path)
+          data = client.get_file_data(path)
+          file = File.new(path, data)
+
+          [ 200, headers(file), [data] ]
+        end
+
+        def client
+          @options[:client]
+        end
+
+        def key_for_path(path)
+          path
+        end
+
+        def headers(file)
+          {
+            "Content-Type"   => file.content_type(@options[:default_content_type]),
+            "Content-Length" => file.length
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/endpoint/caching.rb

@@ -0,0 +1,40 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # Adds support for expires headers. You can specify a number or a proc
+      # that will recieve (path, ext, mime) as arguements. You should return
+      # the number of seconds to cache.
+      module Caching
+        def initialize(*)
+          super
+          @options[:expires] ||= false
+        end
+
+        def headers(file)
+          super.merge( cache_control_header(file) )
+        end
+
+        private
+
+        def cache_control_header(file)
+          if @options[:expires]
+            { "Cache-Control" => "max-age=#{max_age(file)}, public" }
+          else
+            {}
+          end
+        end
+
+        def max_age(file)
+          if @options[:expires].respond_to?(:call)
+            @options[:expires].call(file.path, file.extname, file.content_type)
+          else
+            @options[:expires]
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/endpoint/client.rb

@@ -0,0 +1,41 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # Provides a default client if one is not passed in a a param. It is
+      # recommended to use the default client if you can
+      module Client
+        def initialize(*)
+          super
+          @options[:client] ||= default_client
+        end
+
+        def default_client
+          ::MogileFS::MogileFS.new(config)
+        end
+
+        # If `Rack::MogileFS` detects it is inside a Rails app, it will look
+        # for a yaml config in `config/mogilefs.yml` that looks like this:
+        # 
+        #     development:
+        #       connection:
+        #         domain: "development.myapp.com"
+        #         hosts:
+        #           - 127.0.0.1:7001
+        #           - 127.0.0.1:7001
+        #       class: "file"
+        #     staging:
+        #       ...
+        def config
+          if defined?(Rails)
+            yml = YAML.load_file( Rails.root.join("config/mogilefs.yml") )
+            yml[Rails.env]["connection"].symbolize_keys
+          else
+            { :domain => "default", :hosts => ["127.0.0.1:7001"] }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/endpoint/mapper.rb

@@ -0,0 +1,25 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # Adds ability to pass in a custom mapper to map PATH_INFO to a
+      # MogileFS key. By default it is assumed that the path is the same as
+      # the key. For example your keys will look like this:
+      #
+      #     "/assets/images/myimage.gif"
+      #
+      # Create a custom mapper like this:
+      #
+      #     Rack::MogileFS::Endpoint.new(
+      #       :mapper => lambda { |path| "/namespace/" + path }
+      #     )
+      module Mapper
+        def key_for_path(path)
+          @options[:mapper].respond_to?(:call) ?
+          @options[:mapper].call(path) : super
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/endpoint/reproxy.rb

@@ -0,0 +1,36 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # Adds reproxy support. To activate:
+      #
+      #     Rack::MogileFS::Endpoint.new :strategy => :reproxy
+      module Reproxy
+        def initialize(*)
+          super
+          @options[:strategy] ||= :serve
+        end
+
+        def serve_file(path)
+          if @options[:strategy] == :reproxy
+            reproxy(path)
+          else
+            super
+          end
+        end
+
+        def reproxy(path)
+          paths = client.get_paths(path)
+          file  = File.new(path, nil)
+
+          [ 200, {
+            "Content-Type"     => file.content_type,
+            "X-Accel-Redirect" => "/reproxy",
+            "X-Reproxy-Url"    => paths.join(" ")
+          }, [] ]
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/endpoint/rescues.rb

@@ -0,0 +1,36 @@
+module Rack
+  class MogileFS
+    class Endpoint
+
+      # Catches some potential MogileFS exceptions and will return sensible
+      # HTTP status codes. You can disable with:
+      #
+      #     Rack::MogileFS::Endpoint.new :debug => true
+      module Rescues
+        def initialize(*)
+          super
+          @options[:debug] ||= false
+        end
+
+        def call(env)
+          if @options[:debug]
+            super
+          else
+            with_rescues { super }
+          end
+        end
+
+        def with_rescues
+          yield
+        rescue ::MogileFS::Backend::UnknownKeyError => e
+          [ 404, { "Content-Type" => "text/html" }, [e.message] ]
+        rescue ::MogileFS::UnreachableBackendError => e
+          [ 503, { "Content-Type" => "text/html" }, [e.message] ]
+        rescue ::MogileFS::Error => e
+          [ 500, { "Content-Type" => "text/html" }, [e.message] ]
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/mogilefs/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class MogileFS
+    VERSION = "0.3.0"
+  end
+end

data/rack-mogilefs.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack/mogilefs/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rack-mogilefs"
+  s.version     = Rack::MogileFS::VERSION
+  s.platform    = Gem::Platform::RUBY
+
+  s.date        = "2010-09-10"
+  s.summary     = "A rack middleware and/or endpoint to serve up files from MogileFS"
+  s.email       = "bmarini@gmail.com"
+  s.homepage    = "http://github.com/bmarini/rack-mogilefs"
+  s.description = "A rack middleware and/or endpoint to serve up files from MogileFS"
+  s.authors     = ["Ben Marini"]
+
+  s.rubyforge_project = "rack-mogilefs"
+
+  s.add_dependency "mogilefs-client", "~> 2.1.0"
+  s.add_dependency "rack", "~> 1.1.0"
+  s.add_development_dependency "mocha"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/release.rb

@@ -0,0 +1,6 @@
+version = ARGV.pop
+
+puts "Building and pushing Rack::MogileFS..."
+`gem build rack-mogilefs.gemspec`
+`gem push rack-mogilefs-#{version}.gem`
+`rm rack-mogilefs-#{version}.gem`

data/test/caching_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class TestCaching < Test::Unit::TestCase
+  def setup
+    @client = MockMogileFsClient.new
+  end
+
+  def test_expires_with_int
+    @client.expects(:get_file_data).with("/assets/image.png").returns("")
+
+    app_with(
+      :path    => %r{^/assets/*},
+      :client  => @client,
+      :expires => 300
+    )
+
+    get '/assets/image.png'
+    assert_status 200
+    assert_cache_control "max-age=300, public"
+  end
+
+  def test_expires_with_lambda
+    @client.expects(:get_file_data).with("/assets/image.jpg").returns("")
+  
+    app_with(
+      :path    => %r{^/assets/*},
+      :client  => @client,
+      :expires => lambda { |path, ext, mime|
+        mime == "image/jpeg" ? 600 : 300
+      }
+    )
+  
+    get '/assets/image.jpg'
+    assert_status 200
+    assert_cache_control "max-age=600, public"
+  end
+
+end

data/test/content_type_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class TestContentType < Test::Unit::TestCase
+  def setup
+    @client = MockMogileFsClient.new
+  end
+
+  def test_content_type_lookup
+    app_with :path => %r{^/assets/*}, :client => @client
+    get '/assets/asset.txt'
+
+    assert_status 200
+    assert_content_type "text/plain"
+
+    get '/assets/asset.png'
+
+    assert_status 200
+    assert_content_type "image/png"
+
+    get '/assets/asset.xml'
+
+    assert_status 200
+    assert_content_type "application/xml"
+  end
+
+  def test_default_content_type
+    app_with :path => %r{^/assets/*}, :client => @client
+    get '/assets/asset.xxx'
+
+    assert_status 200
+    assert_content_type "image/png"
+  end
+
+end

data/test/mapper_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TestMapper < Test::Unit::TestCase
+  def setup
+    @client = MockMogileFsClient.new
+  end
+
+  def test_custom_key_mapping
+    @client.expects(:get_file_data).with("image.png").returns("")
+    app_with(
+      :path   => %r{^/assets/*},
+      :client => @client,
+      :mapper => lambda { |p| p.sub('/assets/', '') }
+    )
+
+    get '/assets/image.png'
+  end
+
+end

data/test/mogilefs_test.rb

@@ -12,32 +12,6 @@ class TestMiddleWare < Test::Unit::TestCase
     assert_body "Hello, World!"
   end
 
-  def test_unreachable_exception
-    app_with :path => %r{^/assets/*}
-    get '/assets/unreachable.txt'
-
-    assert_status 503
-    assert_body "couldn't connect to mogilefsd backend"
-  end
-
-  def test_unknown_key_exception
-    @client.expects(:get_file_data).raises(MogileFS::Backend::UnknownKeyError)
-
-    app_with :path => %r{^/assets/*}, :client => @client
-    get '/assets/unknown.txt'
-
-    assert_status 404
-  end
-
-  def test_mogilefs_exception
-    @client.expects(:get_file_data).raises(MogileFS::Error)
-
-    app_with :path => %r{^/assets/*}, :client => @client
-    get '/assets/error.txt'
-
-    assert_status 500
-  end
-
   def test_middleware_with_mock_mogile_client
     app_with :path => %r{^/assets/*}, :client => @client
     get '/assets/asset.txt'
@@ -45,41 +19,4 @@ class TestMiddleWare < Test::Unit::TestCase
     assert_body "Mock Data for /assets/asset.txt"
   end
 
-  def test_content_type_lookup
-    app_with :path => %r{^/assets/*}, :client => @client
-    get '/assets/asset.txt'
-
-    assert_status 200
-    assert_content_type "text/plain"
-
-    get '/assets/asset.png'
-
-    assert_status 200
-    assert_content_type "image/png"
-
-    get '/assets/asset.xml'
-
-    assert_status 200
-    assert_content_type "application/xml"
-  end
-
-  def test_default_content_type
-    app_with :path => %r{^/assets/*}, :client => @client
-    get '/assets/asset.xxx'
-
-    assert_status 200
-    assert_content_type "image/png"
-  end
-
-  def test_custom_key_mapping
-    @client.expects(:get_file_data).with("image.png").returns("")
-    app_with(
-      :path   => %r{^/assets/*},
-      :client => @client,
-      :mapper => lambda { |p| p.sub('/assets/', '') }
-    )
-
-    get '/assets/image.png'
-  end
-
 end

data/test/reproxy_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class TestReproxy < Test::Unit::TestCase
+  def setup
+    @client = MockMogileFsClient.new
+  end
+
+  def test_reproxy
+    @client.expects(:get_paths).with("/assets/image.png").returns( %w(/path/1.png /path/2.png) )
+
+    app_with(
+      :path     => %r{^/assets/*},
+      :client   => @client,
+      :strategy => :reproxy
+    )
+
+    get '/assets/image.png'
+    assert_status 200
+    assert_content_type "image/png"
+    assert_equal_header "/reproxy", "X-Accel-Redirect"
+    assert_equal_header "/path/1.png /path/2.png", "X-Reproxy-Url"
+  end
+end

data/test/rescues_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class TestRescues < Test::Unit::TestCase
+  def setup
+    @client = MockMogileFsClient.new
+  end
+
+  def test_debug_mode
+    app_with :path => %r{^/assets/*}, :debug => true
+    assert_raises(MogileFS::UnreachableBackendError) do
+      get '/assets/unreachable.txt'
+    end
+  end
+
+  def test_unreachable_exception
+    app_with :path => %r{^/assets/*}
+    get '/assets/unreachable.txt'
+
+    assert_status 503
+    assert_body "couldn't connect to mogilefsd backend"
+  end
+
+  def test_unknown_key_exception
+    @client.expects(:get_file_data).raises(MogileFS::Backend::UnknownKeyError)
+
+    app_with :path => %r{^/assets/*}, :client => @client
+    get '/assets/unknown.txt'
+
+    assert_status 404
+  end
+
+  def test_mogilefs_exception
+    @client.expects(:get_file_data).raises(MogileFS::Error)
+
+    app_with :path => %r{^/assets/*}, :client => @client
+    get '/assets/error.txt'
+
+    assert_status 500
+  end
+
+end

data/test/test_helper.rb

@@ -1,4 +1,6 @@
 require "rubygems"
+require "bundler/setup"
+
 require "test/unit"
 require "rack"
 require "rack/mock"
@@ -34,6 +36,14 @@ class Test::Unit::TestCase
   end
 
   def assert_content_type(content_type)
-    assert_equal content_type, @response.headers["Content-Type"]
+    assert_equal_header content_type, "Content-Type"
+  end
+
+  def assert_cache_control(cache_control)
+    assert_equal_header cache_control, "Cache-Control"
+  end
+
+  def assert_equal_header(expected, header)
+    assert_equal expected, @response.headers[header]
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rack-mogilefs
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Ben Marini
@@ -40,7 +40,7 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         hash: 19
         segments: 
@@ -51,7 +51,7 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rack
+  name: mocha
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -64,20 +64,6 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id004
 description: A rack middleware and/or endpoint to serve up files from MogileFS
 email: bmarini@gmail.com
 executables: []
@@ -87,13 +73,30 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/rack/mogilefs/endpoint.rb
-- lib/rack/mogilefs.rb
-- lib/rack-mogilefs.rb
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- HISTORY.md
 - README.md
 - Rakefile
-- HISTORY.md
+- lib/rack-mogilefs.rb
+- lib/rack/mogilefs.rb
+- lib/rack/mogilefs/endpoint.rb
+- lib/rack/mogilefs/endpoint/base.rb
+- lib/rack/mogilefs/endpoint/caching.rb
+- lib/rack/mogilefs/endpoint/client.rb
+- lib/rack/mogilefs/endpoint/mapper.rb
+- lib/rack/mogilefs/endpoint/reproxy.rb
+- lib/rack/mogilefs/endpoint/rescues.rb
+- lib/rack/mogilefs/version.rb
+- rack-mogilefs.gemspec
+- release.rb
+- test/caching_test.rb
+- test/content_type_test.rb
+- test/mapper_test.rb
 - test/mogilefs_test.rb
+- test/reproxy_test.rb
+- test/rescues_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/bmarini/rack-mogilefs
@@ -124,11 +127,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: rack-mogilefs
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A rack middleware and/or endpoint to serve up files from MogileFS
 test_files: 
+- test/caching_test.rb
+- test/content_type_test.rb
+- test/mapper_test.rb
 - test/mogilefs_test.rb
+- test/reproxy_test.rb
+- test/rescues_test.rb
 - test/test_helper.rb