rack-gridfs 0.3.0 → 0.4.0

data/CHANGES.rdoc

@@ -0,0 +1,31 @@
+== CHANGE LOG
+
+=== 0.4.0 / May 12, 2011
+
+Major refactoring and loads of new features! Thanks to {Ben Marini}[https://github.com/bmarini]
+for his substantial contributions to this release.
+
+{full commit log}[https://github.com/skinandbones/rack-gridfs/compare/v0.2.0...v0.4.0]
+
+==== Features
+
+- Allow configuration of MongoDB authentication (Steve Sloan)
+- Allow option to look up objects by GridFS filename instead of +ObjectId+
+  (SHIBATA Hiroshi)
+- Return iterable GridIO object instead of file contents, so Rack can stream in
+  chunks (Ches Martin)
+- <tt>Rack::GridFS::Endpoint</tt>: support for mounting as a Rack endpoint in
+  addition to middleware (Ben Marini)
+- Cache headers: set <tt>Last-Modified</tt> and +Etag+ so that
+  <tt>Rack::ConditionalGet</tt> sends 304s. +expires+ option to set
+  <tt>Cache-Control</tt> (Alexander Gräfe & Ben Marini)
+- <tt>mime-types</tt> dependency so GridFS lib can determine content types
+  (Ben Marini)
+- You can now pass a <tt>Mongo::DB</tt> instance instead of discrete database
+  configuration parameters. Connections are retried so we take advantage of a
+  +ReplSetConnection+ in high-availability architectures (Ben Marini)
+
+==== Bug Fixes
+
+- <tt>BSON::ObjectID</tt> renamed to +ObjectId+, and other changes supporting
+  current versions of Mongo libraries

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Blake Carlson
+Copyright (c) 2009-2011 Blake Carlson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -2,53 +2,149 @@
 
 Rack:GridFS is a Rack middleware for creating HTTP endpoints for files
 stored in MongoDB's GridFS.  You can configure a prefix string which
-will be used to match the path of a request and supply an id for looking
-up the file in the GridFS store.
+will be used to match the path of a request, and further look up GridFS
+files based on either their +ObjectId+ or +filename+ field.
 
 For example,
 
   GET '/gridfs/someobjectid'
-  
+
 If the prefix is "gridfs", then the id will be be "someobjectid".
 
-== Mongo Driver Compatibility Notes
+You can also use Rack::GridFS::Endpoint as a rack endpoint if you want to
+handle routing another way
 
-This version is currently based off of mongo-0.20.1.  
+== Mongo Driver Compatibility Notes
 
-As of mongo-0.19.1, there have been significant changes to GridFS.  I do
-not plan to support versions of the mongo driver prior to 0.19.  There are
-some compatibility issues with mongo-0.19 vs. mongo-0.20 (Mongo::ObjectID
-vs. BSON::ObjectID).  For now, I am choosing to support mongo-0.20.
+This version is currently based on mongo-1.2+. As there were significant changes
+to the GridFS API prior to v1.0, you may have luck with the git-tagged version
+0.2.0 of this library with earlier versions of the driver.
 
 == Installation
 
-  sudo gem install skinandbones-rack-gridfs --source=http://gems.github.com
+  gem install rack-gridfs
+
+== Features
+- Use as rack middleware or mount as a rack endpoint
+- File lookup using a path or object id
+- Chunked transfer encoding, keeps memory usage low
+- Content-Type header set using 'mime-types' gem
+- Last-Modified and Etag headers set automatically for conditional get support
+- Cache-Control header support
+- High availability when using replication sets
 
 == Usage
 
   require 'rack/gridfs'
-  use Rack::GridFS, :hostname => 'localhost', :port => 27017, :database => 'test', :prefix => 'gridfs'
+  use Rack::GridFS, :prefix => 'gridfs', :hostname => 'localhost', :port => 27017, :database => 'test'
 
-You must specify MongoDB database details:
-- hostname: the hostname/IP where the MongoDB server is running.  Default 'localhost'.
-- port: the port of the MongoDB server.  Default 27017.
-- database: the MongoDB database to connect to.
-- prefix: a string used to match against incoming paths and route to through the middleware.  Default 'gridfs'.
+Options:
+- +prefix+: a string used to match against incoming paths and route to through
+  the middleware.  Default 'gridfs'.
+- +lookup+: whether to look up a file based on <tt>:id</tt> or <tt>:path</tt>
+  (example below).  Default is <tt>:id</tt>.
 
-== Sinatra Example
+You must also specify MongoDB database details:
+- +hostname+: the hostname/IP where the MongoDB server is running.  Default 'localhost'.
+- +port+: the port of the MongoDB server.  Default 27017.
+- +database+: the name of the MongoDB database to connect to.
+- +username+ and +password+: if you need to authenticate to MongoDB.
 
-  # TODO: THIS COULD USE A LOT MORE EXPLANATION!
+Alternatively you can pass in a <tt>Mongo::DB</tt> instance instead:
+- +db+: MongoMapper.database, or Mongoid.database for example.
+
+=== Simple Sinatra Example
 
   require 'rubygems'
   require 'sinatra'
 
   require 'rack/gridfs'
-  use Rack::GridFS, :hostname => 'localhost', :port => 27017, :database => 'test', :prefix => 'gridfs'
+  use Rack::GridFS, :database => 'test', :prefix => 'gridfs'
 
   get /.*/ do
     "The URL did not match a file in GridFS."
   end
 
+=== Usage with Rails 2
+
+To use <tt>Rack::GridFS</tt> in a Rails application, add it as middleware in
+<tt>application.rb</tt> or <tt>config/environments/*</tt>with something like this:
+
+  config.middleware.insert_after Rack::Runtime, Rack::GridFS,
+    :prefix => 'uploads', :database => "my_app_#{Rails.env}"
+
+Run <tt>rake middleware</tt> to decide for yourself where to best place it in
+the middleware stack for your app using {the Rails convenience methods}[http://guides.rubyonrails.org/rails_on_rack.html#configuring-middleware-stack],
+taking into consideration that it can probably be near the top since it simply
+returns a "static" file or a 404.
+
+=== Usage with Rails 3
+
+To use in Rails 3, you can insert into the middleware stack as above, or mount
+the app directly in your routes (recommended). In <tt>config/routes.rb</tt>:
+
+  mount Rack::GridFS::Endpoint.new(:db => Mongoid.database), :at => "gridfs"
+
+This allows for much more straightforward and sensible configuration, if you do
+not require other middleware in front of GridFS (Rack-based authorization, for
+instance).
+
+=== Path (filename) Lookup
+
+The <tt>:lookup => :path</tt> option causes files to be looked up from the GridFS
+store based on their +filename+ field (which can be a full file path) rather than
++ObjectId+ (requests still need to match the +prefix+ you've set). This allows
+you to find files based on essentially arbitrary URLs such as:
+
+    GET '/prefix/media/images/jane_avatar.jpg'
+
+How filenames are set is specific to your application. We'll look at an example
+with Carrierwave below.
+
+*NOTE*: The Mongo Ruby driver will try to create an index on the +filename+
+field for you automatically, but if you are using filename lookup you'll want to
+double-check that it is created appropriately (on slaves only if you have a
+master-slave architecture, etc.).
+
+=== Carrierwave Example
+
+Path lookup works well for usage with Carrierwave[https://github.com/jnicklas/carrierwave].
+As a minimal example with Mongoid:
+
+  # config/initializers/carrierwave.rb
+  CarrierWave.configure do |config|
+    config.storage = :grid_fs
+    config.grid_fs_connection = Mongoid.database
+    config.grid_fs_access_url = "/uploads"
+  end
+
+  # app/uploaders/avatar_uploader.rb
+  class AvatarUploader < CarrierWave::Uploader::Base
+    # (Virtual) path where uploaded files will be stored, appended to the
+    # gridfs_access_url by methods used with view helpers
+    def store_dir
+      "#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    end
+  end
+
+  # app/models/user.rb
+  class User
+    include Mongoid::Document
+    mount_uploader :avatar, AvatarUploader
+  end
+
+  # app/views/user/show.html.erb
+  <%= image_tag(@user.avatar.url) if @user.avatar? %>
+
+This will result in URL paths like <tt>/uploads/user/avatar/4d250d04a8f41c0a31000006/original_filename.jpg</tt>
+being generated for the view helpers, and Carrierwave will store
+<tt>user/avatar/4d250d04a8f41c0a31000006/original_filename.jpg</tt> as the
++filename+ in GridFS. Thus, you can configure <tt>Rack::GridFS</tt> to serve
+these files as such:
+
+  config.middleware.insert_after Rack::Runtime, Rack::GridFS,
+    :prefix => 'uploads', :lookup => :path, :database => "my_app_#{Rails.env}"
+
 == Copyright
 
-Copyright (c) 2010 Blake Carlson. See LICENSE for details.
+Copyright (c) 2010-2011 Blake Carlson. See LICENSE for details.

data/Rakefile

@@ -1,30 +1,5 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name              = "rack-gridfs"
-    gem.summary           = "Rack middleware for creating HTTP endpoints for files stored in MongoDB's GridFS"
-    gem.email             = "blake@coin-operated.net"
-    gem.homepage          = "http://github.com/skinandbones/rack-gridfs"
-    gem.authors           = ["Blake Carlson"]
-    gem.rubyforge_project = "rack-gridfs"
-    
-    gem.add_dependency('rack')
-    gem.add_dependency('mongo', '>=0.20.1')
-    
-    gem.add_development_dependency('mocha', '0.9.4')
-    gem.add_development_dependency('rack-test')
-    gem.add_development_dependency('shoulda')
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "rdoc"
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
@@ -37,29 +12,24 @@ begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
     test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
+    test.test_files = FileList['test/**/*_test.rb']
     test.verbose = true
+    test.rcov_opts << '--exclude /gems/,/Library/,/usr/,spec,lib/tasks'
   end
 rescue LoadError
   task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+    abort "RCov is not available. In order to run rcov, you must: gem install rcov"
   end
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
+  require File.expand_path("../lib/rack/gridfs/version", __FILE__)
 
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "Rack::GridFS #{version}"
-  rdoc.rdoc_files.include('README*')
+  rdoc.title = "Rack::GridFS #{Rack::GridFS::VERSION}"
+  rdoc.rdoc_files.include(%w[ README* CHANGES* ])
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/lib/rack/gridfs.rb

@@ -1,57 +1,52 @@
-require 'timeout'
 require 'mongo'
+require 'mime/types'
 
 module Rack
-  
   class GridFSConnectionError < StandardError ; end
-  
+
+  # Rack middleware that will serve GridFS files from a specified path prefix.
+  # By default the prefix is stripped from the path before file lookup in
+  # GridFS occurs.
+  #
+  # For example:
+  #
+  #     "/gridfs/filename.png" -> "filename.png"
+  #
+  # If you are using Rails you can mount the endpoint directly.
+  #
+  # For example (in config/routes.rb):
+  #
+  #     mount Rack::GridFS::Endpoint, :at => "gridfs"
+
   class GridFS
+    autoload :Endpoint, "rack/gridfs/endpoint"
 
-    attr_reader :hostname, :port, :database, :prefix, :db
-    
-    def initialize(app, options = {})
-      options = {
-        :hostname => 'localhost', 
-        :prefix   => 'gridfs',
-        :port     => Mongo::Connection::DEFAULT_PORT
-      }.merge(options)
-
-      @app        = app
-      @hostname   = options[:hostname]
-      @port       = options[:port]
-      @database   = options[:database]
-      @prefix     = options[:prefix]
-      @db         = nil
-
-      connect!
+    def initialize(app, options={})
+      @app     = app
+      @options = normalize_options(options)
     end
 
     def call(env)
-      request = Rack::Request.new(env)
-      if request.path_info =~ /^\/#{prefix}\/(.+)$/
-        gridfs_request($1)
+      if env['PATH_INFO'] =~ %r{^/#{@options[:prefix]}/*}
+        endpoint.call(env)
       else
         @app.call(env)
       end
     end
 
-    def gridfs_request(id)
-      file = Mongo::Grid.new(db).get(BSON::ObjectID.from_string(id))
-      [200, {'Content-Type' => file.content_type}, [file.read]]
-    rescue Mongo::GridError, BSON::InvalidObjectID
-      [404, {'Content-Type' => 'text/plain'}, ['File not found.']]
-    end
-    
     private
-    
-    def connect!
-      Timeout::timeout(5) do
-        @db = Mongo::Connection.new(hostname).db(database)
+
+    # TODO: doc explanation/example of custom mapper
+    def normalize_options(options)
+      options.tap do |opts|
+        opts[:prefix] ||= "gridfs"
+        opts[:prefix].gsub!(/^\//, '')
+        opts[:mapper] ||= lambda { |path| %r!^/#{options[:prefix]}/(.+)!.match(path)[1] }
       end
-    rescue Exception => e
-      raise Rack::GridFSConnectionError, "Unable to connect to the MongoDB server (#{e.to_s})"
     end
-    
+
+    def endpoint
+      @endpoint ||= Endpoint.new(@options)
+    end
   end
-    
 end

data/lib/rack/gridfs/endpoint.rb

@@ -0,0 +1,13 @@
+require 'rack/gridfs/endpoint/base'
+require 'rack/gridfs/endpoint/caching'
+require 'rack/gridfs/endpoint/connection'
+
+module Rack
+  class GridFS
+    class Endpoint
+      include Base
+      include Connection
+      include Caching
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Rack
+  class GridFS
+    class Endpoint
+      module Base
+        attr_reader :db
+
+        def initialize(options = {})
+          @options = default_options.merge(options)
+
+          @db     = @options[:db]
+          @lookup = @options[:lookup]
+          @mapper = @options[:mapper]
+        end
+
+        def call(env)
+          with_rescues do
+            request = Rack::Request.new(env)
+            key     = key_for_path(request.path_info)
+            file    = find_file(key)
+
+            response_for(file, request)
+          end
+        end
+
+        def key_for_path(path)
+          @mapper.respond_to?(:call) ? @mapper.call(path) : path
+        end
+
+        protected
+
+        def default_options
+          {
+            :lookup => :id,
+            :mapper => lambda { |path| %r!/(.+)!.match(path)[1] }
+          }
+        end
+
+        def with_rescues
+          rescue_connection_failure { yield }
+        rescue Mongo::GridFileNotFound, BSON::InvalidObjectId => e
+          [ 404, {'Content-Type' => 'text/plain'}, ["File not found. #{e}"] ]
+        rescue Mongo::GridError => e
+          [ 500, {'Content-Type' => 'text/plain'}, ["An error occured. #{e}"] ]
+        end
+
+        def rescue_connection_failure(max_retries=60)
+          retries = 0
+          begin
+            yield
+          rescue Mongo::ConnectionFailure => e
+            retries += 1
+            raise e if retries > max_retries
+            sleep(0.5)
+            retry
+          end
+        end
+
+        def response_for(file, request)
+          [ 200, headers(file), file ]
+        end
+
+        def find_file(id_or_path)
+          case @lookup.to_sym
+          when :id   then Mongo::Grid.new(db).get(BSON::ObjectId.from_string(id_or_path))
+          when :path then Mongo::GridFileSystem.new(db).open(id_or_path, "r")
+          end
+        end
+
+        def headers(file)
+          { 'Content-Type' => file.content_type }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Rack
+  class GridFS
+    class Endpoint
+
+      module Caching
+        def initialize(*)
+          super
+          @options[:expires] ||= false
+        end
+
+        protected
+
+        def headers(file)
+          super.merge(
+            'Last-Modified' => file.upload_date.httpdate,
+            'Etag'          => file.files_id.to_s
+          ).merge(cache_control_header)
+        end
+
+        private
+
+        def cache_control_header
+          if @options[:expires]
+            { "Cache-Control" => "max-age=#{@options[:expires]}, public" }
+          else
+            {}
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rack/gridfs/endpoint/connection.rb

@@ -0,0 +1,43 @@
+require 'timeout'
+
+module Rack
+  class GridFS
+    class Endpoint
+
+      module Connection
+        def initialize(*)
+          super
+
+          @hostname, @port, @database, @username, @password =
+            @options.values_at(:hostname, :port, :database, :username, :password)
+        end
+
+        def default_options
+          super.merge({
+            :hostname => 'localhost',
+            :port     => Mongo::Connection::DEFAULT_PORT
+          })
+        end
+
+        def db
+          @db ||= (super || connect!)
+        end
+
+        protected
+
+        def connect!
+          database = nil
+
+          Timeout::timeout(5) do
+            database = Mongo::Connection.new(@hostname, @port).db(@database)
+            database.authenticate(@username, @password) if @username
+          end
+
+          return database
+        rescue Exception => e
+          raise Rack::GridFSConnectionError, "Unable to connect to the MongoDB server (#{e.to_s})"
+        end
+      end
+    end
+  end
+end

data/lib/rack/gridfs/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class GridFS
+    VERSION = "0.4.0"
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rack-gridfs
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Blake Carlson
@@ -9,110 +15,183 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-11 00:00:00 -04:00
+date: 2011-05-13 00:00:00 +07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rack
+  prerelease: false
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  version_requirements: *id001
+  name: rack
 - !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  version_requirements: *id002
   name: mongo
+- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id003
+  name: mime-types
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.20.1
-    version: 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  version_requirements: *id004
+  name: bundler
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  prerelease: false
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.4
-    version: 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
+        version: 0.9.12
+  version_requirements: *id005
+  name: mocha
 - !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id006
   name: rack-test
+- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  version_requirements: *id007
+  name: rake
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  prerelease: false
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: 
-email: blake@coin-operated.net
+  version_requirements: *id008
+  name: shoulda
+description: Rack middleware for creating HTTP endpoints for files stored in MongoDB's GridFS
+email: 
+- blake@coin-operated.net
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
+- CHANGES.rdoc
 - LICENSE
 - README.rdoc
 files: 
-- .gitignore
+- lib/rack/gridfs/endpoint/base.rb
+- lib/rack/gridfs/endpoint/caching.rb
+- lib/rack/gridfs/endpoint/connection.rb
+- lib/rack/gridfs/endpoint.rb
+- lib/rack/gridfs/version.rb
+- lib/rack/gridfs.rb
 - LICENSE
 - README.rdoc
 - Rakefile
-- VERSION
-- example/gridfs_server.rb
-- lib/rack/gridfs.rb
-- rack-gridfs.gemspec
-- test/artifacts/3wolfmoon.jpg
-- test/artifacts/test.html
-- test/artifacts/test.txt
-- test/gridfs_test.rb
-- test/test_helper.rb
+- CHANGES.rdoc
 has_rdoc: true
 homepage: http://github.com/skinandbones/rack-gridfs
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
 rubyforge_project: rack-gridfs
-rubygems_version: 1.3.5
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
-summary: Rack middleware for creating HTTP endpoints for files stored in MongoDB's GridFS
-test_files: 
-- test/gridfs_test.rb
-- test/test_helper.rb
+summary: Serve MongoDB GridFS files from Rack
+test_files: []
+

data/.gitignore

@@ -1,2 +0,0 @@
-rdoc
-pkg

data/VERSION

@@ -1 +0,0 @@
-0.3.0

data/example/gridfs_server.rb

@@ -1,9 +0,0 @@
-require 'rubygems'
-require 'sinatra'
-
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rack', 'gridfs')
-use Rack::GridFS, :hostname => 'localhost', :port => 27017, :database => 'test', :prefix => 'gridfs'
-
-get /.*/ do
-  "Whatchya talking about?"
-end

data/rack-gridfs.gemspec

@@ -1,69 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{rack-gridfs}
-  s.version = "0.3.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Blake Carlson"]
-  s.date = %q{2010-05-11}
-  s.email = %q{blake@coin-operated.net}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "example/gridfs_server.rb",
-     "lib/rack/gridfs.rb",
-     "rack-gridfs.gemspec",
-     "test/artifacts/3wolfmoon.jpg",
-     "test/artifacts/test.html",
-     "test/artifacts/test.txt",
-     "test/gridfs_test.rb",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/skinandbones/rack-gridfs}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{rack-gridfs}
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Rack middleware for creating HTTP endpoints for files stored in MongoDB's GridFS}
-  s.test_files = [
-    "test/gridfs_test.rb",
-     "test/test_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rack>, [">= 0"])
-      s.add_runtime_dependency(%q<mongo>, [">= 0.20.1"])
-      s.add_development_dependency(%q<mocha>, ["= 0.9.4"])
-      s.add_development_dependency(%q<rack-test>, [">= 0"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-    else
-      s.add_dependency(%q<rack>, [">= 0"])
-      s.add_dependency(%q<mongo>, [">= 0.20.1"])
-      s.add_dependency(%q<mocha>, ["= 0.9.4"])
-      s.add_dependency(%q<rack-test>, [">= 0"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rack>, [">= 0"])
-    s.add_dependency(%q<mongo>, [">= 0.20.1"])
-    s.add_dependency(%q<mocha>, ["= 0.9.4"])
-    s.add_dependency(%q<rack-test>, [">= 0"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-  end
-end
-

data/test/artifacts/test.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
-   "http://www.w3.org/TR/html4/strict.dtd">
-
-<html lang="en">
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-	<title>test</title>
-	<meta name="generator" content="TextMate http://macromates.com/">
-	<meta name="author" content="Blake Carlson">
-	<!-- Date: 2009-09-20 -->
-</head>
-<body>
-  Test
-</body>
-</html>

data/test/artifacts/test.txt

@@ -1 +0,0 @@
-Lorem ipsum dolor sit amet.

data/test/gridfs_test.rb

@@ -1,141 +0,0 @@
-require 'test_helper'
-
-class Rack::GridFSTest < Test::Unit::TestCase
-  include Rack::Test::Methods
-  
-  def stub_mongodb_connection
-    Rack::GridFS.any_instance.stubs(:connect!).returns(true)
-  end
-  
-  def test_database_options
-    { :hostname => 'localhost', :port => 27017, :database => 'test', :prefix => 'gridfs' }
-  end
-  
-  def db
-    @db ||= Mongo::Connection.new(test_database_options[:hostname], test_database_options[:port]).db(test_database_options[:database])
-  end
-  
-  def app 
-    gridfs_opts = test_database_options
-    Rack::Builder.new do
-      use Rack::GridFS, gridfs_opts
-      run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    end
-  end
-
-  def load_artifact(filename, content_type)
-    contents = File.read(File.join(File.dirname(__FILE__), 'artifacts', filename))
-    Mongo::Grid.new(db).put(contents, :filename => filename, :content_type => content_type)
-  end
-
-  context "Rack::GridFS" do
-
-    context "on initialization" do
-
-      setup do
-        stub_mongodb_connection
-        @options = { :hostname => 'myhostname.mydomain', :port => 8765, :database => 'mydatabase', :prefix => 'myprefix' }
-      end
-
-      should "have a hostname option" do
-        mware = Rack::GridFS.new(nil, @options)
-        assert_equal @options[:hostname], mware.hostname
-      end
-
-      should "have a default hostname" do
-        mware = Rack::GridFS.new(nil, @options.except(:hostname))
-        assert_equal 'localhost', mware.hostname
-      end
-
-      should "have a port option" do
-        mware = Rack::GridFS.new(nil, @options)
-        assert_equal @options[:port], mware.port
-      end
-
-      should "have a default port" do
-        mware = Rack::GridFS.new(nil, @options.except(:port))
-        assert_equal Mongo::Connection::DEFAULT_PORT, mware.port
-      end
-
-      should "have a database option" do
-        mware = Rack::GridFS.new(nil, @options)
-        assert_equal @options[:database], mware.database
-      end
-
-      should "not have a default database" do
-        mware = Rack::GridFS.new(nil, @options.except(:database))
-        assert_nil mware.database
-      end
-
-      should "have a prefix option" do
-        mware = Rack::GridFS.new(nil, @options)
-        assert_equal mware.prefix, @options[:prefix]
-      end
-      
-      should "have a default prefix" do
-        mware = Rack::GridFS.new(nil, @options.except(:prefix))
-        assert_equal mware.prefix, 'gridfs'
-      end
-
-      should "connect to the MongoDB server" do
-        Rack::GridFS.any_instance.expects(:connect!).returns(true).once
-        Rack::GridFS.new(nil, @options)
-      end
-
-    end
-
-    should "delegate requests with a non-matching prefix" do
-      %w( / /posts /posts/1 /posts/1/comments ).each do |path|
-        get path
-        assert last_response.ok?
-        assert 'Hello, World!', last_response.body
-      end
-    end
-
-    context "with files in GridFS" do
-      setup do
-        @text_id = load_artifact('test.txt', 'text/plain')
-        @html_id = load_artifact('test.html', 'text/html')
-      end
-
-      teardown do
-        db.collection('fs.files').remove
-      end
-
-      should "return TXT files stored in GridFS" do
-        get "/gridfs/#{@text_id}"
-        assert_equal "Lorem ipsum dolor sit amet.", last_response.body
-      end
-
-      should "return the proper content type for TXT files" do
-        get "/gridfs/#{@text_id}"
-        assert_equal 'text/plain', last_response.content_type
-      end
-
-      should "return HTML files stored in GridFS" do
-        get "/gridfs/#{@html_id}"
-        assert_match /html.*?body.*Test/m, last_response.body
-      end
-      
-      should "return the proper content type for HTML files" do
-        get "/gridfs/#{@html_id}"
-        assert_equal 'text/html', last_response.content_type
-      end
-      
-      should "return a not found for a unknown path" do
-        get '/gridfs/unknown'
-        assert last_response.not_found?
-      end
-      
-      should "work for small images" do
-        image_id = load_artifact('3wolfmoon.jpg', 'image/jpeg')
-        get "/gridfs/#{image_id}"
-        assert last_response.ok?
-        assert_equal 'image/jpeg', last_response.content_type
-      end
-    end
-
-  end
-
-end
-

data/test/test_helper.rb

@@ -1,19 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-require 'rack/builder'
-require 'rack/mock'
-require 'rack/test'
-
-require 'mongo'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'rack', 'gridfs')
-
-
-class Hash
-  def except(*keys)
-    rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
-    reject { |key,| rejected.include?(key) }
-  end
-end