plowdawg-carrierwave 0.5.8

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/right_s3.rb

@@ -0,0 +1 @@
+raise "The right_aws library is no longer supported. Please install the 'fog' gem instead."

data/lib/carrierwave/storage/s3.rb

@@ -0,0 +1,240 @@
+# encoding: utf-8
+begin
+  require 'fog'
+rescue LoadError
+  raise "You don't have the 'fog' gem installed. The 'aws', 'aws-s3' and 'right_aws' gems are no longer supported."
+end
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Uploads things to Amazon S3 using the "fog" gem.
+    # You'll need to specify the access_key_id, secret_access_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
+    #
+    # 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
+    #
+    # The following access policies are available:
+    #
+    # [: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
+    #
+    # You can specify a region. US Standard "us-east-1" is the default.
+    #
+    #     CarrierWave.configure do |config|
+    #       config.s3_region = 'eu-west-1'
+    #     end
+    #
+    # Available options are defined in Fog Storage[http://github.com/geemus/fog/blob/master/lib/fog/aws/storage.rb]
+    #
+    #     'eu-west-1' => 's3-eu-west-1.amazonaws.com'
+    #     'us-east-1' => 's3.amazonaws.com'
+    #     'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com'
+    #     'us-west-1' => 's3-us-west-1.amazonaws.com'
+    #
+    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_object(bucket, @path)
+          @headers = result.headers
+          result.body
+        end
+
+        ##
+        # Remove the file from Amazon S3
+        #
+        def delete
+          connection.delete_object(bucket, @path)
+        end
+
+        ##
+        # Returns the url on Amazon's S3 service
+        #
+        # === Returns
+        #
+        # [String] file's url
+        #
+        def url
+          if access_policy == :authenticated_read
+            authenticated_url
+          else
+            public_url
+          end
+        end
+
+        def public_url
+          scheme = use_ssl? ? 'https' : 'http'
+          if cnamed?
+            ["#{scheme}://#{bucket}", path].compact.join('/')
+          else
+            ["#{scheme}://#{bucket}.s3.amazonaws.com", path].compact.join('/')
+          end
+        end
+
+        def authenticated_url
+          connection.get_object_url(bucket, path, Time.now + authentication_timeout)
+        end
+
+        def store(file)
+          content_type ||= file.content_type # this might cause problems if content type changes between read and upload (unlikely)
+          connection.put_object(bucket, path, file.read,
+            {
+              'x-amz-acl' => access_policy.to_s.gsub('_', '-'),
+              'Content-Type' => content_type
+            }.merge(@uploader.s3_headers)
+          )
+        end
+
+        def content_type
+          headers["Content-Type"]
+        end
+
+        def content_type=(type)
+          headers["Content-Type"] = type
+        end
+
+        def size
+           headers['Content-Length'].to_i
+        end
+
+        # Headers returned from file retrieval
+        def headers
+          @headers ||= begin
+            connection.head_object(bucket, @path).headers
+          rescue Excon::Errors::NotFound # Don't die, just return no headers
+            {}
+          end
+        end
+
+      private
+
+        def use_ssl?
+          @uploader.s3_use_ssl
+        end
+
+        def cnamed?
+          @uploader.s3_cnamed
+        end
+
+        def access_policy
+          @uploader.s3_access_policy
+        end
+
+        def bucket
+          @uploader.s3_bucket
+        end
+
+        def authentication_timeout
+          @uploader.s3_authentication_timeout
+        end
+
+        def connection
+          @base.connection
+        end
+
+      end
+
+      ##
+      # Store the file on S3
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::S3::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::S3::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::S3::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+      def connection
+        @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
+
+    end # S3
+  end # Storage
+end # CarrierWave
+