jswanner-carrierwave 0.5.0.beta3

data/lib/carrierwave/storage/abstract.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Storage
+
+    ##
+    # This file serves mostly as a specification for Storage engines. There is no requirement
+    # that storage engines must be a subclass of this class.
+    #
+    class Abstract
+
+      attr_reader :uploader
+
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def identifier
+        uploader.filename
+      end
+
+      def store!(file)
+      end
+
+      def retrieve!(identifier)
+      end
+
+    end # Abstract
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/cloud_files.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require 'cloudfiles'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # 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
+    #
+    #     CarrierWave.configure do |config|
+    #       config.cloud_files_username = "xxxxxx"
+    #       config.cloud_files_api_key = "xxxxxx"
+    #       config.cloud_files_container = "my_container"
+    #     end
+    #
+    # You can optionally include your CDN host name in the configuration.
+    # This is *highly* recommended, as without it every request requires a lookup
+    # of this information.
+    #
+    #   config.cloud_files_cdn_host = "c000000.cdn.rackspacecloud.com"
+    #
+    #
+    class CloudFiles < Abstract
+
+      class File
+
+        def initialize(uploader, base, path)
+          @uploader = uploader
+          @path = path
+          @base = base
+        end
+
+        ##
+        # Returns the current path/filename of the file on Cloud Files. 
+        #
+        # === Returns
+        #
+        # [String] A path
+        #
+        def path
+          @path
+        end
+
+        ##
+        # Reads the contents of the file from Cloud Files
+        #
+        # === Returns
+        #
+        # [String] contents of the file
+        #
+        def read
+          object = cf_container.object(@path)
+          @content_type = object.content_type
+          object.data
+        end
+
+        ##
+        # Remove the file from Cloud Files
+        #
+        def delete
+          cf_container.delete_object(@path)
+        end
+
+        ##
+        # Returns the url on the Cloud Files CDN.  Note that the parent container must be marked as
+        # public for this to work.
+        #
+        # === Returns
+        #
+        # [String] file's url
+        #
+        def url
+          if @uploader.cloud_files_cdn_host
+            "http://" + @uploader.cloud_files_cdn_host + "/" + @path
+          else
+            cf_container.object(@path).public_url
+          end
+        end
+
+        def content_type
+          cf_container.object(@path).content_type
+        end
+
+        def content_type=(new_content_type)
+          headers["content-type"] = new_content_type
+        end
+
+        ##
+        # Writes the supplied data into the object on Cloud Files.
+        #
+        # === Returns
+        #
+        # boolean
+        #
+        def store(data,headers={})
+          object = cf_container.create_object(@path)
+          object.write(data,headers)
+        end
+
+        private
+
+          def headers
+            @headers ||= {  }
+          end
+
+          def container
+            @uploader.cloud_files_container
+          end
+
+          def connection
+            @base.connection
+          end
+          
+          def cf_connection
+            @cf_connection ||= ::CloudFiles::Connection.new(@uploader.cloud_files_username, @uploader.cloud_files_api_key)
+          end
+
+          def cf_container
+            if @cf_container
+              @cf_container
+            else
+              @cf_container = cf_connection.create_container(container)
+              @cf_container.make_public
+              @cf_container
+            end
+          end
+          
+
+      end
+
+      ##
+      # Store the file on Cloud Files
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::CloudFiles::File] the stored file
+      #
+      def store!(file)
+        cloud_files_options = {'Content-Type' => file.content_type}
+        f = CarrierWave::Storage::CloudFiles::File.new(uploader, self, uploader.store_path)
+        f.store(file.read,cloud_files_options)
+        f
+      end
+
+      # Do something to retrieve the file
+      #
+      # @param [String] identifier uniquely identifies the file
+      #
+      # [identifier (String)] uniquely identifies the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::CloudFiles::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::CloudFiles::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+
+    end # CloudFiles
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/file.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Storage
+
+    ##
+    # File storage stores file to the Filesystem (surprising, no?). There's really not much
+    # to it, it uses the store_dir defined on the uploader as the storage location. That's
+    # pretty much it.
+    #
+    class File < Abstract
+
+      ##
+      # Move the file to the uploader's store path.
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def store!(file)
+        path = ::File.expand_path(uploader.store_path, uploader.root)
+        file.move_to(path, uploader.permissions)
+        file
+      end
+
+      ##
+      # Retrieve the file from its store path
+      #
+      # === Parameters
+      #
+      # [identifier (String)] the filename of the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def retrieve!(identifier)
+        path = ::File.expand_path(uploader.store_path(identifier), uploader.root)
+        CarrierWave::SanitizedFile.new(path)
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/grid_fs.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require 'mongo'
+
+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, path)
+          @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
+          grid.open(@path, 'r').data
+        end
+
+        def write(file)
+          grid.open(@uploader.store_path, 'w', :content_type => file.content_type) do |f| 
+            f.write(file.read)
+          end
+        end
+
+        def delete
+          grid.delete(@path)
+        end
+
+        def content_type
+          grid.open(@path, 'r').content_type
+        end
+        
+        def file_length
+          grid.open(@path, 'r').file_length
+        end
+
+      protected
+
+        def database
+          @connection ||= begin
+            host = @uploader.grid_fs_host
+            port = @uploader.grid_fs_port
+            database = @uploader.grid_fs_database
+            username = @uploader.grid_fs_username
+            password = @uploader.grid_fs_password
+            db = Mongo::Connection.new(host, port).db(database)
+            db.authenticate(username, password) if username && password
+            db
+          end
+        end
+        
+        def grid
+          @grid ||= Mongo::GridFileSystem.new(database)
+        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)
+        stored = CarrierWave::Storage::GridFS::File.new(uploader, uploader.store_path)
+        stored.write(file)
+        stored
+      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, uploader.store_path(identifier))
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/right_s3.rb

@@ -0,0 +1,3 @@
+
+raise "The right_aws library is no longer supported. Please install the updated 'aws' library with support for Ruby 1.9 and euro buckets"
+

data/lib/carrierwave/storage/s3.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+begin
+  require 'aws'
+rescue LoadError
+  raise "You don't have the 'aws' gem installed. 'aws-s3' and 'right_aws' are no longer supported."
+end
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Uploads things to Amazon S3 webservices using the "aws" library (aws gem). 
+    # In order for CarrierWave to connect to Amazon S3, you'll need to specify an access key id, secret key
+    # and bucket
+    #
+    #     CarrierWave.configure do |config|
+    #       config.s3_access_key_id = "xxxxxx"
+    #       config.s3_secret_access_key = "xxxxxx"
+    #       config.s3_bucket = "my_bucket_name"
+    #     end
+    #
+    # The AWS::S3Interface is used directly as opposed to the normal AWS::S3::Bucket et.al. classes.
+    # This gives much improved performance and avoids unnecessary requests.
+    #
+    # You can set the access policy for the uploaded files:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.s3_access_policy = 'public-read'
+    #     end
+    #
+    # The default is 'public-read'. For more options see:
+    #
+    # http://docs.amazonwebservices.com/AmazonS3/latest/RESTAccessPolicy.html#RESTCannedAccessPolicies
+    #
+    # For backwards compatability with the original aws-s3 library, if the old +config.s3_access+ is set it
+    # will be converted to the appropriate access policy:
+    #
+    # [:private]              No one else has any access rights.
+    # [:public_read]          The anonymous principal is granted READ access.
+    #                         If this policy is used on an object, it can be read from a
+    #                         browser with no authentication.
+    # [:public_read_write]    The anonymous principal is granted READ and WRITE access.
+    # [:authenticated_read]   Any principal authenticated as a registered Amazon S3 user
+    #                         is granted READ access.
+    #
+    # You can change the generated url to a cnamed domain by setting the cnamed config:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.s3_cnamed = true
+    #       config.s3_bucket = 'bucketname.domain.tld'
+    #     end
+    #
+    # Now the resulting url will be
+    #     
+    #     http://bucketname.domain.tld/path/to/file
+    #
+    # instead of
+    #
+    #     http://bucketname.domain.tld.s3.amazonaws.com/path/to/file
+    #
+    class S3 < Abstract
+
+      class File
+
+        def initialize(uploader, base, path)
+          @uploader = uploader
+          @path = path
+          @base = base
+        end
+
+        ##
+        # Returns the current path of the file on S3
+        #
+        # === Returns
+        #
+        # [String] A path
+        #
+        def path
+          @path
+        end
+
+        ##
+        # Reads the contents of the file from S3
+        #
+        # === Returns
+        #
+        # [String] contents of the file
+        #
+        def read
+          result = connection.get(bucket, @path)
+          @headers = result[:headers]
+          result[:object]
+        end
+
+        ##
+        # Remove the file from Amazon S3
+        #
+        def delete
+          connection.delete(bucket, @path)
+        end
+
+        ##
+        # Returns the url on Amazon's S3 service
+        #
+        # === Returns
+        #
+        # [String] file's url
+        #
+        def url
+          if @uploader.s3_cnamed
+            ["http://#{@uploader.s3_bucket}", @path].compact.join('/')
+          else
+            ["http://#{@uploader.s3_bucket}.s3.amazonaws.com", @path].compact.join('/')
+          end
+        end
+
+        def store(file)
+          content_type ||= file.content_type # this might cause problems if content type changes between read and upload (unlikely)
+          connection.put(bucket, @path, file.read,
+            {
+              'x-amz-acl' => access_policy,
+              'content-type' => content_type
+            }.merge(@uploader.s3_headers)
+          )
+        end
+
+        # The Amazon S3 Access policy ready to send in storage request headers.
+        def access_policy
+          return @access_policy unless @access_policy.blank?
+          if @uploader.s3_access_policy.blank? 
+            if !@uploader.s3_access.blank?
+              @access_policy = @uploader.s3_access.to_s.gsub(/_/, '-')
+            else
+              @access_policy = 'public-read'
+            end
+          else
+            @access_policy = @uploader.s3_access_policy
+          end
+        end
+
+        def content_type
+          headers["content-type"]
+        end
+
+        def content_type=(type)
+          headers["content-type"] = type
+        end
+
+        # Headers returned from file retrieval
+        def headers
+          @headers ||= {}
+        end
+ 
+      private
+    
+        def bucket
+          @uploader.s3_bucket
+        end
+
+        def connection
+          @base.connection
+        end
+
+      end
+
+      ##
+      # Store the file on S3
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::RightS3::File] the stored file
+      #
+      def store!(file)
+        f = CarrierWave::Storage::S3::File.new(uploader, self, uploader.store_path)
+        f.store(file)
+        f
+      end
+
+      # Do something to retrieve the file
+      #
+      # @param [String] identifier uniquely identifies the file
+      #
+      # [identifier (String)] uniquely identifies the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::RightS3::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::S3::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+      def connection
+        @connection ||= Aws::S3Interface.new(
+          uploader.s3_access_key_id, uploader.s3_secret_access_key,
+          :multi_thread => uploader.s3_multi_thread
+        )
+      end
+
+    end # S3
+  end # Storage
+end # CarrierWave