carrierwave 0.3.5.2 → 0.4.0

data/lib/carrierwave/compatibility/paperclip.rb

@@ -78,8 +78,8 @@ module CarrierWave
 
       def mappings
         {
-          :rails_root   => lambda{|u, f| CarrierWave.config[:root] },
-          :rails_env    => lambda{|u, f| CarrierWave.config[:env] },
+          :rails_root   => lambda{|u, f| Rails.root },
+          :rails_env    => lambda{|u, f| Rails.env },
           :class        => lambda{|u, f| u.model.class.name.underscore.pluralize},
           :id           => lambda{|u, f| u.model.id },
           :id_partition => lambda{|u, f| ("%09d" % u.model.id).scan(/\d{3}/).join("/")},

data/lib/carrierwave/core_ext/inheritable_attributes.rb

@@ -58,7 +58,7 @@ class Class
         RUBY
       end
     end
-  end
+  end unless Class.respond_to?(:extlib_inheritable_reader)
 
   # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
   # each subclass has a copy of parent's attribute.
@@ -86,7 +86,7 @@ class Class
         RUBY
       end
     end
-  end
+  end unless Class.respond_to?(:extlib_inheritable_writer)
 
   # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
   # each subclass has a copy of parent's attribute.
@@ -100,5 +100,5 @@ class Class
   def extlib_inheritable_accessor(*syms)
     extlib_inheritable_reader(*syms)
     extlib_inheritable_writer(*syms)
-  end
+  end unless Class.respond_to?(:extlib_inheritable_accessor)
 end

data/lib/carrierwave/mount.rb

@@ -26,11 +26,6 @@ module CarrierWave
       @uploaders
     end
 
-    ##
-    # === Returns
-    #
-    # [Hash{Symbol => Hash}] options for mounted uploaders
-    #
     def uploader_options
       @uploader_options ||= {}
       @uploader_options = superclass.uploader_options.merge(@uploader_options)
@@ -38,6 +33,26 @@ module CarrierWave
       @uploader_options
     end
 
+    ##
+    # Return a particular option for a particular uploader
+    #
+    # === Parameters
+    #
+    # [column (Symbol)] The column the uploader is mounted at
+    # [option (Symbol)] The option, e.g. validate_integrity
+    #
+    # === Returns
+    #
+    # [Object] The option value
+    #
+    def uploader_option(column, option)
+      if uploader_options[column].has_key?(option)
+        uploader_options[column][option]
+      else
+        uploaders[column].send(option)
+      end
+    end
+
     ##
     # Mounts the given uploader on the given column. This means that assigning
     # and reading from the column will upload and retrieve files. Supposing
@@ -70,9 +85,6 @@ module CarrierWave
     # [image_cache]             Returns a string that identifies the cache location of the file 
     # [image_cache=]            Retrieves the file from the cache based on the given cache name
     #
-    # [image_uploader]          Returns an instance of the uploader
-    # [image_uploader=]         Sets the uploader (be careful!)
-    #
     # [remove_image]            An attribute reader that can be used with a checkbox to mark a file for removal
     # [remove_image=]           An attribute writer that can be used with a checkbox to mark a file for removal
     # [remove_image?]           Whether the file should be removed when store_image! is called.
@@ -131,7 +143,7 @@ module CarrierWave
       end
 
       uploaders[column.to_sym] = uploader
-      uploader_options[column.to_sym] = CarrierWave.config[:mount].merge(options)
+      uploader_options[column.to_sym] = options
 
       include CarrierWave::Mount::Extension
 
@@ -165,14 +177,6 @@ module CarrierWave
           _mounter(:#{column}).url(*args)
         end
 
-        def #{column}_uploader
-          _mounter(:#{column}).uploader
-        end
-
-        def #{column}_uploader=(uploader)
-          _mounter(:#{column}).uploader = uploader
-        end
-
         def #{column}_cache
           _mounter(:#{column}).cache_name
         end
@@ -244,9 +248,8 @@ module CarrierWave
     # we don't pollute the model with a lot of methods.
     class Mounter #:nodoc:
 
-      attr_reader :column, :record, :options
-
-      attr_accessor :uploader, :integrity_error, :processing_error, :remove
+      attr_reader :column, :record, :integrity_error, :processing_error
+      attr_accessor :remove
 
       def initialize(record, column, options={})
         @record = record
@@ -277,14 +280,14 @@ module CarrierWave
 
       def cache(new_file)
         uploader.cache!(new_file)
-        self.integrity_error = nil
-        self.processing_error = nil
+        @integrity_error = nil
+        @processing_error = nil
       rescue CarrierWave::IntegrityError => e
-        self.integrity_error = e
-        raise e unless options[:ignore_integrity_errors]
+        @integrity_error = e
+        raise e unless option(:ignore_integrity_errors)
       rescue CarrierWave::ProcessingError => e
-        self.processing_error = e
-        raise e unless options[:ignore_processing_errors]
+        @processing_error = e
+        raise e unless option(:ignore_processing_errors)
       end
 
       def cache_name
@@ -323,9 +326,13 @@ module CarrierWave
       end
 
     private
+      
+      def option(name)
+        record.class.uploader_option(column, name)
+      end
 
       def serialization_column
-        options[:mount_on] || column
+        option(:mount_on) || column
       end
 
     end # Mounter

data/lib/carrierwave/orm/activerecord.rb

@@ -16,8 +16,8 @@ module CarrierWave
       alias_method :read_uploader, :read_attribute
       alias_method :write_uploader, :write_attribute
 
-      validates_integrity_of column if uploader_options[column.to_sym][:validate_integrity]
-      validates_processing_of column if uploader_options[column.to_sym][:validate_processing]
+      validates_integrity_of column if uploader_option(column.to_sym, :validate_integrity)
+      validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
 
       after_save "store_#{column}!"
       before_save "write_#{column}_identifier"

data/lib/carrierwave/processing/rmagick.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-unless Module.const_defined?('Magick')
+unless defined? Magick 
   begin
     require 'rmagick'
   rescue LoadError

data/lib/carrierwave/storage/abstract.rb

@@ -15,8 +15,6 @@ module CarrierWave
         @uploader = uploader
       end
 
-      def self.setup!; end
-
       def identifier
         uploader.filename
       end

data/lib/carrierwave/storage/file.rb

@@ -22,9 +22,8 @@ module CarrierWave
       # [CarrierWave::SanitizedFile] a sanitized file
       #
       def store!(file)
-        path = ::File.join(uploader.store_path)
-        path = ::File.expand_path(path, uploader.public)
-        file.move_to(path, CarrierWave.config[:permissions])
+        path = ::File.expand_path(uploader.store_path, uploader.root)
+        file.move_to(path, uploader.permissions)
         file
       end
 
@@ -40,8 +39,7 @@ module CarrierWave
       # [CarrierWave::SanitizedFile] a sanitized file
       #
       def retrieve!(identifier)
-        path = ::File.join(uploader.store_path(identifier))
-        path = ::File.expand_path(path, uploader.public)
+        path = ::File.expand_path(uploader.store_path(identifier), uploader.root)
         CarrierWave::SanitizedFile.new(path)
       end
 

data/lib/carrierwave/storage/grid_fs.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'mongo'
+require 'mongo/gridfs'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # The GridFS store uses MongoDB's GridStore file storage system to store files
+    #
+    class GridFS < Abstract
+
+      class File
+
+        def initialize(uploader, database, path)
+          @database = database
+          @path = path
+          @uploader = uploader
+        end
+
+        def path
+          nil
+        end
+
+        def url
+          unless @uploader.grid_fs_access_url
+            nil
+          else
+            [@uploader.grid_fs_access_url, @path].join("/")
+          end
+        end
+
+        def read
+          ::GridFS::GridStore.read(@database, @path)
+        end
+
+        def delete
+          ::GridFS::GridStore.unlink(@database, @path)
+        end
+
+      end
+
+      ##
+      # Store the file in MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def store!(file)
+        ::GridFS::GridStore.open(database, uploader.store_path, 'w') do |f|
+          f.write file.read
+        end
+        CarrierWave::Storage::GridFS::File.new(uploader, database, uploader.store_path)
+      end
+
+      ##
+      # Retrieve the file from MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [identifier (String)] the filename of the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::GridFS::File] a sanitized file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::GridFS::File.new(uploader, database, uploader.store_path(identifier))
+      end
+
+    private
+
+      def database
+        @connection ||= begin
+          host = uploader.grid_fs_host
+          database = uploader.grid_fs_database
+          Mongo::Connection.new(host).db(database)
+        end
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/s3.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require 'aws/s3'
 
 module CarrierWave
   module Storage
@@ -8,13 +9,17 @@ module CarrierWave
     # CarrierWave to connect to Amazon S3, you'll need to specify an access key id, secret key
     # and bucket
     #
-    #     CarrierWave.config[:s3][:access_key_id] = "xxxxxx"
-    #     CarrierWave.config[:s3][:secret_access_key] = "xxxxxx"
-    #     CarrierWave.config[:s3][:bucket] = "my_bucket_name"
+    #     CarrierWave.configure do |config|
+    #       config.s3_access_key_id = "xxxxxx"
+    #       config.s3_secret_access_key = "xxxxxx"
+    #       config.s3_bucket = "my_bucket_name"
+    #     end
     #
     # You can also set the access policy for the uploaded files:
     #
-    #     CarrierWave.config[:s3][:access] = :public_read
+    #     CarrierWave.configure do |config|
+    #       config.s3_access = :public
+    #     end
     #
     # Possible values are the 'canned access control policies' provided in the aws/s3 gem,
     # they are:
@@ -31,23 +36,26 @@ module CarrierWave
     #
     # You can change the generated url to a cnamed domain by setting the cnamed config:
     #
-    #     CarrierWave.config[:s3][:cnamed] = true
+    #     CarrierWave.configure do |config|
+    #       config.s3_cnamed = true
+    #       config.s3_bucket = 'bucketname.domain.tld'
+    #     end
     #
-    # No the resulting url will be
+    # Now the resulting url will be
     #     
-    #     http://bucket_name.domain.tld/path/to/file
+    #     http://bucketname.domain.tld/path/to/file
     #
     # instead of
     #
-    #     http://s3.amazonaws.com/bucket_name.domain.tld/path/to/file
+    #     http://s3.amazonaws.com/bucketname.domain.tld/path/to/file
     #
     class S3 < Abstract
 
       class File
 
-        def initialize(path, identifier)
+        def initialize(uploader, path)
+          @uploader = uploader
           @path = path
-          @identifier = identifier
         end
 
         ##
@@ -61,17 +69,6 @@ module CarrierWave
           @path
         end
 
-        ##
-        # Returns the filename on S3
-        #
-        # === Returns
-        #
-        # [String] path to the file
-        #
-        def identifier
-          @identifier
-        end
-
         ##
         # Reads the contents of the file from S3
         #
@@ -80,14 +77,14 @@ module CarrierWave
         # [String] contents of the file
         #
         def read
-          AWS::S3::S3Object.value @path, bucket
+          AWS::S3::S3Object.value @path, @uploader.s3_bucket
         end
 
         ##
         # Remove the file from Amazon S3
         #
         def delete
-          AWS::S3::S3Object.delete @path, bucket
+          AWS::S3::S3Object.delete @path, @uploader.s3_bucket
         end
 
         ##
@@ -98,10 +95,10 @@ module CarrierWave
         # [String] file's url
         #
         def url
-          if CarrierWave::config[:s3][:cnamed]
-            ["http://", bucket, @path].compact.join('/')
+          if @uploader.s3_cnamed 
+            ["http://", @uploader.s3_bucket, @path].compact.join('/')
           else
-            ["http://s3.amazonaws.com", bucket, @path].compact.join('/')
+            ["http://s3.amazonaws.com", @uploader.s3_bucket, @path].compact.join('/')
           end
         end
 
@@ -137,46 +134,6 @@ module CarrierWave
           @s3_object ||= AWS::S3::S3Object.find(@path, bucket)
         end
 
-
-      private
-
-        def bucket
-          CarrierWave::Storage::S3.bucket
-        end
-
-        def access
-          CarrierWave::Storage::S3.access
-        end
-
-      end
-
-      ##
-      # === Returns
-      #
-      # [String] the bucket set in the config options
-      #
-      def self.bucket
-        CarrierWave.config[:s3][:bucket]
-      end
-
-      ##
-      # === Returns
-      #
-      # [Symbol] the access priviliges the uploaded files should have
-      #
-      def self.access
-        CarrierWave.config[:s3][:access]
-      end
-
-      ##
-      # Connect to Amazon S3
-      #
-      def self.setup!
-        require 'aws/s3'
-        AWS::S3::Base.establish_connection!(
-          :access_key_id     => CarrierWave.config[:s3][:access_key_id],
-          :secret_access_key => CarrierWave.config[:s3][:secret_access_key]
-        )
       end
 
       ##
@@ -191,8 +148,9 @@ module CarrierWave
       # [CarrierWave::Storage::S3] the stored file
       #
       def store!(file)
-        AWS::S3::S3Object.store(::File.join(uploader.store_path), file.read, self.class.bucket, :access => self.class.access)
-        CarrierWave::Storage::S3::File.new(uploader.store_path, uploader.filename)
+        connect!(uploader)
+        AWS::S3::S3Object.store(uploader.store_path, file.read, uploader.s3_bucket, :access => uploader.s3_access)
+        CarrierWave::Storage::S3::File.new(uploader, uploader.store_path)
       end
 
       # Do something to retrieve the file
@@ -207,7 +165,17 @@ module CarrierWave
       # [CarrierWave::Storage::S3::File] the stored file
       #
       def retrieve!(identifier)
-        CarrierWave::Storage::S3::File.new(uploader.store_path(identifier), identifier)
+        connect!(uploader)
+        CarrierWave::Storage::S3::File.new(uploader, uploader.store_path(identifier))
+      end
+
+    private
+
+      def connect!(uploader)
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => uploader.s3_access_key_id,
+          :secret_access_key => uploader.s3_secret_access_key
+        )
       end
 
     end # S3