carrierwave 0.3.5.2 → 0.4.0

data/Generators

@@ -1,4 +1,4 @@
 scope 'merb-gen' do
-  dir = File.join(File.dirname(__FILE__), 'lib', 'generators/')
+  dir = File.join(File.dirname(__FILE__), 'merb_generators/')
   Merb.add_generators dir + 'uploader_generator'
 end

data/History.txt

@@ -1,3 +1,14 @@
+=== Version 0.4.0 2009-09
+
+* [changed] the `public` option has been renamed `root` and the old `root` option was removed. No more ambiguity.
+* [changed] Major *breaking* changes to the configuration syntax.
+
+* [removed] support for `default_path`
+* [removed] the `cache_to_cache_dir` option
+* [removed] storage no longer calls `setup!` on storage engines
+
+* [added] Support for MongoDB's GridFS store
+
 === Version 0.3.4 2009-09-01
 
 * [added] `default_url` as a replacement for `default_path`

data/Manifest.txt

@@ -3,7 +3,6 @@ History.txt
 Manifest.txt
 README.rdoc
 Rakefile
-carrierwave.gemspec
 cucumber.yml
 features/caching.feature
 features/file_storage.feature
@@ -12,6 +11,7 @@ features/file_storage_overridden_store_dir.feature
 features/file_storage_reversing_processor.feature
 features/fixtures/bork.txt
 features/fixtures/monkey.txt
+features/grid_fs_storage.feature
 features/mount_activerecord.feature
 features/mount_datamapper.feature
 features/step_definitions/activerecord_steps.rb
@@ -43,23 +43,23 @@ lib/carrierwave/processing/rmagick.rb
 lib/carrierwave/sanitized_file.rb
 lib/carrierwave/storage/abstract.rb
 lib/carrierwave/storage/file.rb
+lib/carrierwave/storage/grid_fs.rb
 lib/carrierwave/storage/s3.rb
 lib/carrierwave/test/matchers.rb
 lib/carrierwave/uploader.rb
 lib/carrierwave/uploader/cache.rb
 lib/carrierwave/uploader/callbacks.rb
-lib/carrierwave/uploader/default_path.rb
+lib/carrierwave/uploader/configuration.rb
 lib/carrierwave/uploader/default_url.rb
 lib/carrierwave/uploader/extension_whitelist.rb
 lib/carrierwave/uploader/mountable.rb
-lib/carrierwave/uploader/paths.rb
 lib/carrierwave/uploader/processing.rb
 lib/carrierwave/uploader/proxy.rb
 lib/carrierwave/uploader/remove.rb
 lib/carrierwave/uploader/store.rb
 lib/carrierwave/uploader/url.rb
 lib/carrierwave/uploader/versions.rb
-lib/generators/uploader_generator.rb
+merb_generators/uploader_generator.rb
 rails_generators/uploader/USAGE
 rails_generators/uploader/templates/uploader.rb
 rails_generators/uploader/uploader_generator.rb
@@ -77,8 +77,10 @@ spec/orm/mongomapper_spec.rb
 spec/orm/sequel_spec.rb
 spec/sanitized_file_spec.rb
 spec/spec_helper.rb
+spec/storage/grid_fs_spec.rb
+spec/storage/s3_spec.rb
 spec/uploader/cache_spec.rb
-spec/uploader/default_path_spec.rb
+spec/uploader/configuration_spec.rb
 spec/uploader/default_url_spec.rb
 spec/uploader/extension_whitelist_spec.rb
 spec/uploader/mountable_spec.rb

data/README.rdoc

@@ -20,6 +20,8 @@ Install the latest stable release:
 
     [sudo] gem install carrierwave
 
+CarrierWave is hosted *only* on {Gemcutter}[http://gemcutter.org] as of version 0.4.0.
+
 In Merb, add it as a dependency to your config/dependencies.rb:
     
     dependency 'carrierwave'
@@ -59,7 +61,7 @@ You can use your uploader class to store and retrieve files like this:
 
 CarrierWave gives you a +store+ for permanent storage, and a +cache+ for
 temporary storage. You can use different stores, at the moment a filesystem
-store and an Amazon S3 store are bundled.
+store, an Amazon S3 store and a store for MongoDB's GridFS are bundled.
 
 Most of the time you are going to want to use CarrierWave together with an ORM.
 It is quite simple to mount uploaders on columns in your model, so you can
@@ -72,25 +74,13 @@ need to require the relevant extension manually, e.g.:
 
     require 'carrierwave/orm/activerecord'
 
-Open your model file. For ActiveRecord do something like:
-
-    class User < ActiveRecord::Base
-      mount_uploader :avatar, AvatarUploader
-    end
-
-Or for DataMapper:
+Open your model file and mount the uploader:
 
     class User
-      include DataMapper::Resource
-
       mount_uploader :avatar, AvatarUploader
     end
 
-Or for Sequel
-
-    class User < Sequel::Model
-      mount_uploader :avatar, AvatarUploader
-    end
+This works the same with all supported ORMs.
 
 Now you can cache files by assigning them to the attribute, they will
 automatically be stored when the record is saved.
@@ -115,6 +105,18 @@ method:
 
 This works for the file storage as well as Amazon S3.
 
+== Securing uploads
+
+Certain file might be dangerous if uploaded to the wrong location, such as php files or other script files. CarrierWave allows you to specify a white-list of allowed extensions.
+
+If you're mounting the uploader, uploading a file with the wrong extension will make the record invalid instead. Otherwise, an error is raised.
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def extension_white_list
+        %w(jpg jpeg gif png)
+      end
+    end
+
 == Adding versions
 
 Often you'll want to add different versions of the same file. The classic
@@ -171,7 +173,7 @@ like this:
       </p>
     <% end %>
 
-It might be a good idea to show th user that a file has been uploaded, in the
+It might be a good idea to show the user that a file has been uploaded, in the
 case of images, a small thumbnail would be a good indicator:
 
     <% form_for @user do |f| %>
@@ -183,12 +185,6 @@ case of images, a small thumbnail would be a good indicator:
       </p>
     <% end %>
 
-NOTE: this feature currently requires write access to your filesystem. If write
-access is unavailable you will not be able to upload files. You can prevent
-CarrierWave from writing to the file system by setting
-`CarrierWave.config[:cache_to_cache_dir] = false`. This will however break
-redisplays of forms.
-
 == Providing a default URL
 
 In many cases, especially when working with images, it might be a good idea to
@@ -201,25 +197,68 @@ this easily by overriding the +default_url+ method in your uploader:
       end
     end
 
+== Configuring CarrierWave
+
+CarrierWave has a broad range of configuration options, which you can configure, both globally and on a per-uploader basis:
+
+    CarrierWave.configure do |config|
+      config.permissions = 0666
+      config.storage = :s3
+    end
+
+Or alternatively:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      permissions 0777
+    end
+
 == Using Amazon S3
 
 You'll need to configure a bucket, access id and secret key like this:
 
-    CarrierWave.config[:s3][:access_key_id] = 'xxxxxx'
-    CarrierWave.config[:s3][:secret_access_key] = 'xxxxxx'
-    CarrierWave.config[:s3][:bucket] = 'name_of_bucket'
+    CarrierWave.configure do |config|
+      config.s3_access_key_id = 'xxxxxx'
+      config.s3_secret_access_key = 'xxxxxx'
+      config.s3_bucket = 'name_of_bucket'
+    end
 
 Do this in an initializer in Rails, and in a +before_app_loads+ block in Merb.
 
 And then in your uploader, set the storage to :s3
 
-    class AvatarUploader < 
+    class AvatarUploader < CarrierWave::Uploader::Base
       storage :s3
     end
 
 That's it! You can still use the +CarrierWave::Uploader#url+ method to return
 the url to the file on Amazon S3
 
+== Using MongoDB's GridFS store
+
+You'll need to configure the database and host to use:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_database = 'my_mongo_database'
+      config.grid_fs_host = 'mongo.example.com'
+    end
+
+The defaults are 'carrierwave' and 'localhost'.
+
+And then in your uploader, set the storage to +:grid_fs+:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :grid_fs
+    end
+
+Since GridFS doesn't make the files available via HTTP, you'll need to stream
+them yourself. In Rails for example, you could use the +send_data+ method. You
+can tell CarrierWave the URL you will serve your images from, allowing it to
+generate the correct URL, by setting eg:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_access_url = "/image/show"
+    end
+
 == Using RMagick
 
 If you're uploading images, you'll probably want to manipulate them in some way,
@@ -298,6 +337,8 @@ These people have contributed their time and effort to CarrierWave:
 * Andrew Timberlake
 * Durran Jordan
 * Scott Motte
+* Sho Fukamachi
+* Sam Lown
 
 == License
 

data/Rakefile

@@ -14,15 +14,18 @@ $hoe = Hoe.spec 'carrierwave' do
   self.rubyforge_name = self.name
   self.readme_file = 'README.rdoc'
   self.version = CarrierWave::VERSION
+  self.extra_dev_deps << ['newgem', '>=1.5.2']
   self.extra_dev_deps << ['rspec', '>=1.2.8']
   self.extra_dev_deps << ['cucumber', '>=0.3.96']
   self.extra_dev_deps << ['activerecord', '>=2.3.3']
   self.extra_dev_deps << ['sqlite3-ruby', '>=1.2.5']
   self.extra_dev_deps << ['dm-core', '>=0.9.11']
+  self.extra_dev_deps << ['data_objects', '>=0.9.12']
   self.extra_dev_deps << ['do_sqlite3', '>=0.9.11']
   self.extra_dev_deps << ['sequel', '>=3.2.0']
   self.extra_dev_deps << ['rmagick', '>=2.10.0']
-  self.extra_dev_deps << ['jnunemaker-mongomapper', '>=0.3.3']
+  self.extra_dev_deps << ['mongo_mapper', '>=0.5.4']
+  self.extra_dev_deps << ['aws-s3', '>=0.6.2']
   self.extra_rdoc_files << 'README.rdoc'
 end
 

data/features/grid_fs_storage.feature

@@ -0,0 +1,32 @@
+Feature: uploader with file storage
+  In order to be awesome
+  As a developer using CarrierWave
+  I want to upload files to the filesystem
+  
+  Background:
+    Given an uploader class that uses the 'grid_fs' storage
+    And an instance of that class    
+  
+  Scenario: store a file
+    When I store the file 'fixtures/bork.txt'
+    Then the contents of the file should be 'this is a file'
+  
+  Scenario: store two files in succession
+    When I store the file 'fixtures/bork.txt'
+    Then the contents of the file should be 'this is a file'
+    When I store the file 'fixtures/monkey.txt'
+    Then the contents of the file should be 'this is another file'
+  
+  Scenario: cache a file and then store it
+    When I cache the file 'fixtures/bork.txt'
+    Then there should be a file called 'bork.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'bork.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/bork.txt'
+    And there should not be a file at 'public/uploads/bork.txt'
+    When I store the file
+    Then the contents of the file should be 'this is a file'
+  
+  Scenario: retrieving a file from cache then storing
+    Given the file 'fixtures/bork.txt' is cached file at 'public/uploads/tmp/20090212-2343-8336-0348/bork.txt'
+    When I retrieve the cache name '20090212-2343-8336-0348/bork.txt' from the cache
+    And I store the file
+    Then the contents of the file should be 'this is a file'

data/features/step_definitions/general_steps.rb

@@ -1,13 +1,18 @@
 # encoding: utf-8
 
-Given /^an uploader class that uses the 'file' storage$/ do
+Given /^an uploader class that uses the '(.*?)' storage$/ do |kind|
   @klass = Class.new(CarrierWave::Uploader::Base)
+  @klass.storage = kind.to_sym
 end
 
 Given /^an instance of that class$/ do
   @uploader = @klass.new
 end
 
+Then /^the contents of the file should be '(.*?)'$/ do |contents|
+  @uploader.read.chomp.should == contents
+end
+
 Given /^that the uploader reverses the filename$/ do
   @klass.class_eval do
     def filename

data/features/support/env.rb

@@ -1,34 +1,23 @@
 # encoding: utf-8
 
 $TESTING=true
-$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 
-require 'rubygems'
 require File.join(File.dirname(__FILE__), 'activerecord')
 require File.join(File.dirname(__FILE__), 'datamapper')
 
-if ENV["AS"]
-  puts "--> using ActiveSupport"
-  require 'activesupport'
-elsif ENV["EXTLIB"]
-  puts "--> using Extlib"
-  require 'extlib'
-end
-
-require 'tempfile'
-#require 'ruby-debug'
 require 'spec'
-
 require 'carrierwave'
 
 alias :running :lambda
 
 def file_path( *paths )
-  File.expand_path(File.join(File.dirname(__FILE__), '..', *paths))
+  File.expand_path(File.join('..', *paths), File.dirname(__FILE__))
 end
 
-CarrierWave.config[:public] = file_path('public')
-CarrierWave.config[:root] = file_path
+CarrierWave.configure do |config|
+  config.root = file_path('public')
+end
 
 After do
   FileUtils.rm_rf(file_path("public"))

data/lib/carrierwave.rb

@@ -7,39 +7,17 @@ require 'carrierwave/core_ext/inheritable_attributes'
 
 module CarrierWave
 
-  VERSION = "0.3.5.2"
+  VERSION = "0.4.0"
 
   class << self
-    attr_accessor :config, :logger
-
-    def logger
-      return @logger if @logger
-      require 'logger'
-      @logger = Logger.new(STDOUT)
-    end
-
-    ##
-    # Generates a unique cache id for use in the caching system
-    #
-    # === Returns
-    #
-    # [String] a cache id in the format YYYYMMDD-HHMM-PID-RND
-    #
-    def generate_cache_id
-      Time.now.strftime('%Y%m%d-%H%M') + '-' + Process.pid.to_s + '-' + ("%04d" % rand(9999))
+    def configure(&block)
+      CarrierWave::Uploader::Base.configure(&block)
     end
   end
 
   class UploadError < StandardError; end
-  class NoFileError < UploadError; end
-  class FormNotMultipart < UploadError
-    def message
-      "You tried to assign a String or a Pathname to an uploader, for security reasons, this is not allowed.\n\n If this is a file upload, please check that your upload form is multipart encoded."
-    end
-  end
   class IntegrityError < UploadError; end
   class InvalidParameter < UploadError; end
-  # Should be used by methods used as process callbacks.
   class ProcessingError < UploadError; end
 
   autoload :SanitizedFile, 'carrierwave/sanitized_file'
@@ -51,6 +29,7 @@ module CarrierWave
     autoload :Abstract, 'carrierwave/storage/abstract'
     autoload :File, 'carrierwave/storage/file'
     autoload :S3, 'carrierwave/storage/s3'
+    autoload :GridFS, 'carrierwave/storage/grid_fs'
   end
 
   module Uploader
@@ -61,13 +40,12 @@ module CarrierWave
     autoload :Processing, 'carrierwave/uploader/processing'
     autoload :Versions, 'carrierwave/uploader/versions'
     autoload :Remove, 'carrierwave/uploader/remove'
-    autoload :Paths, 'carrierwave/uploader/paths'
     autoload :ExtensionWhitelist, 'carrierwave/uploader/extension_whitelist'
-    autoload :DefaultPath, 'carrierwave/uploader/default_path'
     autoload :DefaultUrl, 'carrierwave/uploader/default_url'
     autoload :Proxy, 'carrierwave/uploader/proxy'
     autoload :Url, 'carrierwave/uploader/url'
     autoload :Mountable, 'carrierwave/uploader/mountable'
+    autoload :Configuration, 'carrierwave/uploader/configuration'
   end
 
   module Compatibility
@@ -80,52 +58,43 @@ module CarrierWave
 
 end
 
-CarrierWave.config = {
-  :permissions => 0644,
-  :storage => :file,
-  :use_cache => true,
-  :storage_engines => {
+CarrierWave.configure do |config|
+  config.permissions = 0644
+  config.storage_engines = {
     :file => "CarrierWave::Storage::File",
-    :s3 => "CarrierWave::Storage::S3"
-  },
-  :s3 => {
-    :access => :public_read
-  },
-  :store_dir => 'uploads',
-  :cache_dir => 'uploads/tmp',
-  :cache_to_cache_dir => true,
-  :mount => {
-    :ignore_integrity_errors => true,
-    :ignore_processing_errors => true,
-    :validate_integrity => true,
-    :validate_processing => true
+    :s3 => "CarrierWave::Storage::S3",
+    :grid_fs => "CarrierWave::Storage::GridFS"
   }
-}
+  config.storage = :file
+  config.s3_access = :public_read
+  config.grid_fs_database = 'carrierwave'
+  config.grid_fs_host = 'localhost'
+  config.store_dir = 'uploads'
+  config.cache_dir = 'uploads/tmp'
+  config.ignore_integrity_errors = true
+  config.ignore_processing_errors = true
+  config.validate_integrity = true
+  config.validate_processing = true
+end
 
 if defined?(Merb)
-  CarrierWave.logger = Merb.logger
-  CarrierWave.config[:root] = Merb.root
-  CarrierWave.config[:public] = Merb.dir_for(:public)
-  Merb.add_generators File.dirname(__FILE__) / 'generators' / 'uploader_generator'
-
+  CarrierWave.configure do |config|
+    config.root = Merb.dir_for(:public)
+  end
   Merb::BootLoader.before_app_loads do
     # Setup path for uploaders and load all of them before classes are loaded
     Merb.push_path(:uploaders, Merb.root / 'app' / 'uploaders', '*.rb')
     Dir.glob(File.join(Merb.load_paths[:uploaders])).each {|f| require f }
   end
-
 elsif defined?(Rails)
-  CarrierWave.logger = Rails.logger
-  CarrierWave.config[:root] = Rails.root
-  CarrierWave.config[:public] = File.join(Rails.root, 'public')
-
+  CarrierWave.configure do |config|
+    config.root = File.join(Rails.root, 'public')
+  end
   ActiveSupport::Dependencies.load_paths << File.join(Rails.root, "app", "uploaders")
-
 elsif defined?(Sinatra)
-
-  CarrierWave.config[:root] = Sinatra::Application.root
-  CarrierWave.config[:public] = Sinatra::Application.public
-
+  CarrierWave.configure do |config|
+    config.root = Sinatra::Application.public
+  end
 end