potatosalad-carrierwave 0.5.7

data/lib/carrierwave/storage/cloud_files.rb

@@ -0,0 +1,188 @@
+# 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.  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.
+    # 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
+          begin
+            cf_container.delete_object(@path)
+          rescue ::CloudFiles::Exception::NoSuchObject
+            # If the file's not there, don't panic
+            nil
+          end
+        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
+            begin
+              cf_container.object(@path).public_url
+            rescue ::CloudFiles::Exception::NoSuchObject
+              nil
+            end
+          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
+            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
+              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
+
+      ##
+      # 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,47 @@
+# 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.copy_to(path, uploader.permissions)
+      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/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

@@ -0,0 +1,136 @@
+# encoding: utf-8
+require 'mongo'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # The GridFS store uses MongoDB's GridStore file storage system to store files
+    #
+    # There are two ways of configuring the GridFS connection. Either you create a
+    # 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"
+    #       config.grid_fs_port = "27017"
+    #       config.grid_fs_database = "your_dbs_app_name"
+    #       config.grid_fs_username = "user"
+    #       config.grid_fs_password = "verysecret"
+    #       config.grid_fs_access_url = "/images"
+    #     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)
+    # you can also reuse this connection:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.storage = :grid_fs
+    #       config.grid_fs_connection = Mongoid.database
+    #       config.grid_fs_access_url = "/images"
+    #     end
+    #
+    class GridFS < Abstract
+
+      class File
+
+        def initialize(uploader, path)
+          @path = path
+          @uploader = uploader
+        end
+
+        def path
+          @path
+        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 ||= @uploader.grid_fs_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 @@
+raise "The right_aws library is no longer supported. Please install the 'fog' gem instead."