carrierwave 0.5.1 → 0.5.4

data/lib/carrierwave/storage/cloud_files.rb

@@ -5,14 +5,18 @@ module CarrierWave
   module Storage
 
     ##
-    # Uploads things to Rackspace Cloud Files webservices using the Rackspace libraries (cloudfiles gem). 
+    # Uploads things to Rackspace Cloud Files webservices using the Rackspace libraries (cloudfiles gem).
     # In order for CarrierWave to connect to Cloud Files, you'll need to specify an username, api key
-    # and container
+    # and container.  Optional arguments are config.cloud_files_snet (using the private internal 
+    # Rackspace network for communication) and config.cloud_files_auth_url (for connecting to Rackspace's 
+    # UK infrastructure or an OpenStack Swift installation)
     #
     #     CarrierWave.configure do |config|
     #       config.cloud_files_username = "xxxxxx"
     #       config.cloud_files_api_key = "xxxxxx"
     #       config.cloud_files_container = "my_container"
+    #       config.cloud_files_auth_url = "https://lon.auth.api.rackspacecloud.com/v1.0"
+    #       config.cloud_files_snet = true
     #     end
     #
     # You can optionally include your CDN host name in the configuration.
@@ -33,7 +37,7 @@ module CarrierWave
         end
 
         ##
-        # Returns the current path/filename of the file on Cloud Files. 
+        # Returns the current path/filename of the file on Cloud Files.
         #
         # === Returns
         #
@@ -60,7 +64,12 @@ module CarrierWave
         # Remove the file from Cloud Files
         #
         def delete
-          cf_container.delete_object(@path)
+          begin
+            cf_container.delete_object(@path)
+          rescue ::CloudFiles::Exception::NoSuchObject
+            # If the file's not there, don't panic
+            nil
+          end
         end
 
         ##
@@ -75,7 +84,11 @@ module CarrierWave
           if @uploader.cloud_files_cdn_host
             "http://" + @uploader.cloud_files_cdn_host + "/" + @path
           else
-            cf_container.object(@path).public_url
+            begin
+              cf_container.object(@path).public_url
+            rescue ::CloudFiles::Exception::NoSuchObject
+              nil
+            end
           end
         end
 
@@ -112,21 +125,28 @@ module CarrierWave
           def connection
             @base.connection
           end
-          
+
           def cf_connection
-            @cf_connection ||= ::CloudFiles::Connection.new(@uploader.cloud_files_username, @uploader.cloud_files_api_key)
+            config = {:username => @uploader.cloud_files_username, :api_key => @uploader.cloud_files_api_key}
+            config[:auth_url] = @uploader.cloud_files_auth_url if @uploader.respond_to?(:cloud_files_auth_url)
+            config[:snet] = @uploader.cloud_files_snet if @uploader.respond_to?(:cloud_files_snet)
+            @cf_connection ||= ::CloudFiles::Connection.new(config)
           end
 
           def cf_container
             if @cf_container
               @cf_container
             else
-              @cf_container = cf_connection.create_container(container)
-              @cf_container.make_public
+              begin
+                @cf_container = cf_connection.container(container)
+              rescue NoSuchContainerException
+                @cf_container = cf_connection.create_container(container)
+                @cf_container.make_public
+              end
               @cf_container
             end
           end
-          
+
 
       end
 

data/lib/carrierwave/storage/fog.rb

@@ -0,0 +1,332 @@
+# encoding: utf-8
+
+begin
+  require 'fog'
+rescue LoadError
+  raise "You don't have the 'fog' gem installed"
+end
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Stores things using the "fog" gem.
+    #
+    # fog supports storing files with AWS, Google, Local and Rackspace
+    #
+    # You need to setup some options to configure your usage:
+    #
+    # [:fog_credentials]  credentials for service
+    # [:fog_directory]    specifies name of directory to store data in, assumed to already exist
+    #
+    # [:fog_attributes]                   (optional) additional attributes to set on files
+    # [:fog_host]                         (optional) non-default host to serve files from
+    # [:fog_public]                       (optional) public readability, defaults to true
+    # [:fog_authenticated_url_expiration] (optional) time (in seconds) that authenticated urls
+    #   will be valid, when fog_public is false and provider is AWS or Google, defaults to 600
+    #
+    #
+    # AWS credentials contain the following keys:
+    #
+    # [:aws_access_key_id]
+    # [:aws_secret_access_key]
+    # [:region]                 (optional) defaults to 'us-east-1'
+    #   :region should be one of ['eu-west-1', 'us-east-1', 'ap-southeast-1', 'us-west-1', 'ap-northeast-1']
+    #
+    #
+    # Google credentials contain the following keys:
+    # [:google_storage_access_key_id]
+    # [:google_storage_secrete_access_key]
+    #
+    #
+    # Local credentials contain the following keys:
+    #
+    # [:local_root]             local path to files
+    #
+    #
+    # Rackspace credentials contain the following keys:
+    #
+    # [:rackspace_username]
+    # [:rackspace_api_key]
+    #
+    #
+    # A full example with AWS credentials:
+    #     CarrierWave.configure do |config|
+    #       config.fog_credentials = {
+    #         :aws_access_key_id => 'xxxxxx',
+    #         :aws_secret_access_key => 'yyyyyy',
+    #         :provider => 'AWS'
+    #       }
+    #       config.fog_directory = 'directoryname'
+    #       config.fog_public = true
+    #     end
+    #
+    class Fog < Abstract
+
+      ##
+      # Store a file
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::Fog::File] the stored file
+      #
+      def store!(file)
+        f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path)
+        f.store(file)
+        f
+      end
+
+      ##
+      # Retrieve a file
+      #
+      # === Parameters
+      #
+      # [identifier (String)] unique identifier for file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::Fog::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+      def connection
+        @connection ||= begin
+          ::Fog::Storage.new(uploader.fog_credentials)
+        end
+      end
+
+      class File
+
+        ##
+        # Current local path to file
+        #
+        # === Returns
+        #
+        # [String] a path to file
+        #
+        attr_reader :path
+
+        ##
+        # Return all attributes from file
+        #
+        # === Returns
+        #
+        # [Hash] attributes from file
+        #
+        def attributes
+          file.attributes
+        end
+
+        ##
+        # Return a temporary authenticated url to a private file, if available
+        # Only supported for AWS and Google providers
+        #
+        # === Returns
+        #
+        # [String] temporary authenticated url
+        #   or
+        # [NilClass] no authenticated url available
+        #
+        def authenticated_url
+          if ['AWS', 'Google'].include?(@uploader.fog_credentials[:provider])
+            # avoid a get by using local references
+            local_directory = connection.directories.new(:key => @uploader.fog_directory)
+            local_file = local_directory.files.new(:key => path)
+            local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration)
+          else
+            nil
+          end
+        end
+
+        ##
+        # Lookup value for file content-type header
+        #
+        # === Returns
+        #
+        # [String] value of content-type
+        #
+        def content_type
+          @content_type || file.content_type
+        end
+
+        ##
+        # Set non-default content-type header (default is file.content_type)
+        #
+        # === Returns
+        #
+        # [String] returns new content type value
+        #
+        def content_type=(new_content_type)
+          @content_type = new_content_type
+        end
+
+        ##
+        # Remove the file from service
+        #
+        # === Returns
+        #
+        # [Boolean] true for success or raises error
+        #
+        def delete
+          # avoid a get by just using local reference
+          directory.files.new(:key => path).destroy
+        end
+
+        ##
+        # deprecated: All attributes from file (includes headers)
+        #
+        # === Returns
+        #
+        # [Hash] attributes from file
+        #
+        def headers
+          location = caller.first
+          warning = "[yellow][WARN] headers is deprecated, use attributes instead[/]"
+          warning << " [light_black](#{location})[/]"
+          Formatador.display_line(warning)
+          attributes
+        end
+
+        def initialize(uploader, base, path)
+          @uploader, @base, @path = uploader, base, path
+        end
+
+        ##
+        # Read content of file from service
+        #
+        # === Returns
+        #
+        # [String] contents of file
+        def read
+          file.body
+        end
+
+        ##
+        # Return size of file body
+        #
+        # === Returns
+        #
+        # [Integer] size of file body
+        #
+        def size
+          file.content_length
+        end
+
+        ##
+        # Write file to service
+        #
+        # === Returns
+        #
+        # [Boolean] true on success or raises error
+        def store(new_file)
+          @content_type ||= new_file.content_type
+          @file = directory.files.create({
+            :body         => new_file.read,
+            :content_type => @content_type,
+            :key          => path,
+            :public       => @uploader.fog_public
+          }.merge(@uploader.fog_attributes))
+          true
+        end
+
+        ##
+        # Return a url to a public file, if available
+        #
+        # === Returns
+        #
+        # [String] public url
+        #   or
+        # [NilClass] no public url available
+        #
+        def public_url
+          if host = @uploader.fog_host
+            "#{host}/#{path}"
+          else
+            # AWS/Google optimized for speed over correctness
+            case @uploader.fog_credentials[:provider]
+            when 'AWS'
+              # if directory is a valid subdomain, use that style for access
+              if @uploader.fog_directory.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+                "https://#{@uploader.fog_directory}.s3.amazonaws.com/#{path}"
+              else
+                # directory is not a valid subdomain, so use path style for access
+                "https://s3.amazonaws.com/#{@uploader.fog_directory}/#{path}"
+              end
+            when 'Google'
+              "https://commondatastorage.googleapis.com/#{@uploader.fog_directory}/#{path}"
+            else
+              # avoid a get by just using local reference
+              directory.files.new(:key => path).public_url
+            end
+          end
+        end
+
+        ##
+        # Return url to file, if avaliable
+        #
+        # === Returns
+        #
+        # [String] url
+        #   or
+        # [NilClass] no url available
+        #
+        def url
+          if !@uploader.fog_public
+            authenticated_url
+          else
+            public_url
+          end
+        end
+
+      private
+
+        ##
+        # connection to service
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::Storage] connection to service
+        #
+        def connection
+          @base.connection
+        end
+
+        ##
+        # local reference to directory containing file
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::Directory] containing directory
+        #
+        def directory
+          @directory ||= begin
+            connection.directories.new(
+              :key    => @uploader.fog_directory,
+              :public => @uploader.fog_public
+            )
+          end
+        end
+
+        ##
+        # lookup file
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::File] file data from remote service
+        #
+        def file
+          @file ||= directory.files.get(path)
+        end
+
+      end
+
+    end # Fog
+
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/grid_fs.rb

@@ -11,7 +11,7 @@ module CarrierWave
     # connection or you reuse an existing connection.
     #
     # Creating a connection looks something like this:
-    # 
+    #
     #     CarrierWave.configure do |config|
     #       config.storage = :grid_fs
     #       config.grid_fs_host = "your-host.com"
@@ -23,7 +23,7 @@ module CarrierWave
     #     end
     #
     #   In the above example your documents url will look like:
-    #   
+    #
     #      http://your-app.com/images/:document-identifier-here
     #
     # When you already have a Mongo connection object (for example through Mongoid)
@@ -45,7 +45,7 @@ module CarrierWave
         end
 
         def path
-          nil
+          @path
         end
 
         def url
@@ -61,7 +61,7 @@ module CarrierWave
         end
 
         def write(file)
-          grid.open(@uploader.store_path, 'w', :content_type => file.content_type) do |f| 
+          grid.open(@uploader.store_path, 'w', :content_type => file.content_type) do |f|
             f.write(file.read)
           end
         end
@@ -73,7 +73,7 @@ module CarrierWave
         def content_type
           grid.open(@path, 'r').content_type
         end
-        
+
         def file_length
           grid.open(@path, 'r').file_length
         end
@@ -92,7 +92,7 @@ module CarrierWave
             db
           end
         end
-        
+
         def grid
           @grid ||= Mongo::GridFileSystem.new(database)
         end

data/lib/carrierwave/storage/s3.rb

@@ -123,15 +123,16 @@ module CarrierWave
         end
 
         def public_url
+          scheme = use_ssl? ? 'https' : 'http'
           if cnamed?
-            ["http://#{bucket}", path].compact.join('/')
+            ["#{scheme}://#{bucket}", path].compact.join('/')
           else
-            ["http://#{bucket}.s3.amazonaws.com", path].compact.join('/')
+            ["#{scheme}://#{bucket}.s3.amazonaws.com", path].compact.join('/')
           end
         end
 
         def authenticated_url
-          connection.get_object_url(bucket, path, Time.now + 60 * 10)
+          connection.get_object_url(bucket, path, Time.now + authentication_timeout)
         end
 
         def store(file)
@@ -167,6 +168,10 @@ module CarrierWave
 
       private
 
+        def use_ssl?
+          @uploader.s3_use_ssl
+        end
+
         def cnamed?
           @uploader.s3_cnamed
         end
@@ -179,6 +184,10 @@ module CarrierWave
           @uploader.s3_bucket
         end
 
+        def authentication_timeout
+          @uploader.s3_authentication_timeout
+        end
+
         def connection
           @base.connection
         end
@@ -217,10 +226,11 @@ module CarrierWave
       end
 
       def connection
-        @connection ||= Fog::AWS::Storage.new(
-          :aws_access_key_id => uploader.s3_access_key_id,
-          :aws_secret_access_key => uploader.s3_secret_access_key,
-          :region => uploader.s3_region
+        @connection ||= ::Fog::Storage.new(
+          :aws_access_key_id      => uploader.s3_access_key_id,
+          :aws_secret_access_key  => uploader.s3_secret_access_key,
+          :provider               => 'AWS',
+          :region                 => uploader.s3_region
         )
       end
 

data/lib/carrierwave/uploader/cache.rb

@@ -7,7 +7,7 @@ module CarrierWave
       "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
-  
+
   ##
   # Generates a unique cache id for use in the caching system
   #
@@ -37,7 +37,7 @@ module CarrierWave
         #   CarrierWave.clean_cached_files!
         #
         # === Note
-        # 
+        #
         # This only works as long as you haven't done anything funky with your cache_dir.
         # It's recommended that you keep cache files in one place only.
         #
@@ -63,6 +63,19 @@ module CarrierWave
         @cache_id
       end
 
+      ##
+      # Caches the remotely stored file
+      #
+      # This is useful when about to process images. Most processing solutions
+      # require the file to be stored on the local filesystem.
+      #
+      def cache_stored_file!
+        sanitized = SanitizedFile.new :tempfile => StringIO.new(file.read),
+          :filename => File.basename(path), :content_type => file.content_type
+
+        cache! sanitized
+      end
+
       ##
       # Returns a String which uniquely identifies the currently cached file for later retrieval
       #
@@ -87,9 +100,10 @@ module CarrierWave
       #
       def cache!(new_file)
         new_file = CarrierWave::SanitizedFile.new(new_file)
-        raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
 
         unless new_file.empty?
+          raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
+
           with_callbacks(:cache, new_file) do
             self.cache_id = CarrierWave.generate_cache_id unless cache_id
 

data/lib/carrierwave/uploader/callbacks.rb

@@ -6,33 +6,27 @@ module CarrierWave
       extend ActiveSupport::Concern
 
       included do
-        class_inheritable_accessor :_before_callbacks, :_after_callbacks
+        class_attribute :_before_callbacks, :_after_callbacks,
+          :instance_writer => false
+        self._before_callbacks = Hash.new []
+        self._after_callbacks = Hash.new []
       end
 
       def with_callbacks(kind, *args)
-        self.class._before_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+        self.class._before_callbacks[kind].each { |c| send c, *args }
         yield
-        self.class._after_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+        self.class._after_callbacks[kind].each { |c| send c, *args }
       end
 
       module ClassMethods
-        
-        def _before_callbacks_for(kind) #:nodoc:
-          (self._before_callbacks || { kind => [] })[kind] || []
-        end
-
-        def _after_callbacks_for(kind) #:nodoc:
-          (self._after_callbacks || { kind => [] })[kind] || []
-        end
-
-        def before(kind, callback)          
-          self._before_callbacks ||= {}
-          self._before_callbacks[kind] = _before_callbacks_for(kind) + [callback]
+        def before(kind, callback)
+          self._before_callbacks = self._before_callbacks.
+            merge kind => _before_callbacks[kind] + [callback]
         end
 
         def after(kind, callback)
-          self._after_callbacks ||= {}
-          self._after_callbacks[kind] = _after_callbacks_for(kind) + [callback]
+          self._after_callbacks = self._after_callbacks.
+            merge kind => _after_callbacks[kind] + [callback]
         end
       end # ClassMethods