dsturnbull-carrierwave 0.4.5

data/lib/carrierwave/storage/s3.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+require 'aws/s3'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Uploads things to Amazon S3 webservices. It requies the aws/s3 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
+    #
+    # You can also set the access policy for the uploaded files:
+    #
+    #     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:
+    #
+    # [: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.
+    #
+    # The default is :public_read, it should work in most cases.
+    #
+    # You can assign HTTP headers to be used when S3 serves your files:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.s3_headers = {"Content-Disposition" => "attachment; filename=foo.jpg;"}
+    #     end
+    #
+    # You can also set the headers dynamically by overriding the s3_headers method:
+    #
+    #     class MyUploader < CarrierWave::Uploader::Base
+    #       def s3_headers
+    #         { "Expires" => 1.year.from_how.httpdate }
+    #       end
+    #     end
+    #
+    # 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://s3.amazonaws.com/bucketname.domain.tld/path/to/file
+    #
+    class S3 < Abstract
+
+      class File
+
+        def initialize(uploader, path)
+          @uploader = uploader
+          @path = path
+        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
+          AWS::S3::S3Object.value @path, @uploader.s3_bucket
+        end
+
+        ##
+        # Remove the file from Amazon S3
+        #
+        def delete
+          AWS::S3::S3Object.delete @path, @uploader.s3_bucket
+        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://s3.amazonaws.com", @uploader.s3_bucket, @path].compact.join('/')
+          end
+        end
+
+        def about
+          s3_object.about
+        end
+
+        def metadata
+          s3_object.metadata
+        end
+
+        def content_type
+          s3_object.content_type
+        end
+
+        def content_type=(new_content_type)
+          s3_object.content_type = new_content_type
+        end
+
+        def content_disposition
+          s3_object.content_disposition
+        end
+
+        def content_disposition=(new_disposition)
+          s3_object.content_disposition = new_disposition
+        end
+
+        def store
+          s3_object.store
+        end
+
+        def s3_object
+          @s3_object ||= AWS::S3::S3Object.find(@path, @uploader.s3_bucket)
+        end
+
+      end
+
+      ##
+      # Store the file on S3
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::Storage::S3::File)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::S3] the stored file
+      #
+      def store!(file)
+        connect!(uploader)
+        s3_options = {:access => uploader.s3_access, :content_type => file.content_type}
+        s3_options.merge!(uploader.s3_headers)
+        AWS::S3::S3Object.store(uploader.store_path, file.read, uploader.s3_bucket, s3_options)
+        CarrierWave::Storage::S3::File.new(uploader, uploader.store_path)
+      end
+
+      # Do something to retrieve the file
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [String] identifier uniquely identifies the file
+      #
+      # [identifier (String)] uniquely identifies the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::S3::File] the stored file
+      #
+      def retrieve!(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
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/test/matchers.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Test
+
+    ##
+    # These are some matchers that can be used in RSpec specs, to simplify the testing
+    # of uploaders.
+    #
+    module Matchers
+
+      class BeIdenticalTo # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+        def matches?(actual)
+          @actual = actual
+          FileUtils.identical?(@actual, @expected)
+        end
+        def failure_message
+          "expected #{@actual.inspect} to be identical to #{@expected.inspect}"
+        end
+        def negative_failure_message
+          "expected #{@actual.inspect} to not be identical to #{@expected.inspect}"
+        end
+      end
+
+      def be_identical_to(expected)
+        BeIdenticalTo.new(expected)
+      end
+
+      class HavePermissions # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          (File.stat(@actual.path).mode & 0777) == @expected
+        end
+
+        def failure_message
+          "expected #{@actual.inspect} to have permissions #{@expected.to_s(8)}, but they were #{(File.stat(@actual.path).mode & 0777).to_s(8)}"
+        end
+
+        def negative_failure_message
+          "expected #{@actual.inspect} not to have permissions #{@expected.to_s(8)}, but it did"
+        end
+      end
+
+      def have_permissions(expected)
+        HavePermissions.new(expected)
+      end
+
+      class BeNoLargerThan # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          img = ::Magick::Image.read(@actual.current_path).first
+          @actual_width = img.columns
+          @actual_height = img.rows
+          @actual_width <= @width && @actual_height <= @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to be no larger than #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}."
+        end
+
+        def negative_failure_message
+          "expected #{@actual.current_path.inspect} to be larger than #{@width} by #{@height}, but it wasn't."
+        end
+      end
+
+      def be_no_larger_than(width, height)
+        load_rmagick
+        BeNoLargerThan.new(width, height)
+      end
+
+      class HaveDimensions # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          img = ::Magick::Image.read(@actual.current_path).first
+          @actual_width = img.columns
+          @actual_height = img.rows
+          @actual_width == @width && @actual_height == @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have an exact size of #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}."
+        end
+
+        def negative_failure_message
+          "expected #{@actual.current_path.inspect} not to have an exact size of #{@width} by #{@height}, but it did."
+        end
+      end
+
+      def have_dimensions(width, height)
+        load_rmagick
+        HaveDimensions.new(width, height)
+      end
+
+    private
+    
+      def load_rmagick
+        unless defined? Magick 
+          begin
+            require 'rmagick'
+          rescue LoadError
+            require 'RMagick'
+          rescue LoadError
+            puts "WARNING: Failed to require rmagick, image processing may fail!"
+          end
+        end
+      end
+      
+    end # SpecHelper
+  end # Test
+end # CarrierWave

data/lib/carrierwave/uploader/cache.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+module CarrierWave
+
+  class FormNotMultipart < UploadError
+    def message
+      "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
+  #
+  # === Returns
+  #
+  # [String] a cache id in the format YYYYMMDD-HHMM-PID-RND
+  #
+  def self.generate_cache_id
+    Time.now.strftime('%Y%m%d-%H%M') + '-' + Process.pid.to_s + '-' + ("%04d" % rand(9999))
+  end
+
+  module Uploader
+    module Cache
+
+      depends_on CarrierWave::Uploader::Callbacks
+      depends_on CarrierWave::Uploader::Configuration
+
+      module ClassMethods
+
+        ##
+        # Removes cached files which are older than one day. You could call this method
+        # from a rake task to clean out old cached files.
+        #
+        # You can call this method directly on the module like this:
+        #
+        #   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 keen cache files in one place only.
+        #
+        def clean_cached_files!
+          Dir.glob(File.expand_path(File.join(cache_dir, '*'), CarrierWave.root)).each do |dir|
+            time = dir.scan(/(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})/).first.map { |t| t.to_i }
+            time = Time.utc(*time)
+            if time < (Time.now - (60*60*24))
+              FileUtils.rm_rf(dir)
+            end
+          end
+        end
+      end
+
+      ##
+      # Returns true if the uploader has been cached
+      #
+      # === Returns
+      #
+      # [Bool] whether the current file is cached
+      #
+      def cached?
+        @cache_id
+      end
+
+      ##
+      # Returns a String which uniquely identifies the currently cached file for later retrieval
+      #
+      # === Returns
+      #
+      # [String] a cache name, in the format YYYYMMDD-HHMM-PID-RND/filename.txt
+      #
+      def cache_name
+        File.join(cache_id, full_original_filename) if cache_id and original_filename
+      end
+
+      ##
+      # Caches the given file. Calls process! to trigger any process callbacks.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      # === Raises
+      #
+      # [CarrierWave::FormNotMultipart] if the assigned parameter is a string
+      #
+      def cache!(new_file)
+        new_file = CarrierWave::SanitizedFile.new(new_file)
+        raise CarrierWave::FormNotMultipart if new_file.is_path?
+
+        unless new_file.empty?
+          with_callbacks(:cache, new_file) do
+            self.cache_id = CarrierWave.generate_cache_id unless cache_id
+
+            @filename = new_file.filename
+            self.original_filename = new_file.filename
+
+            @file = new_file.copy_to(cache_path, permissions)
+          end
+        end
+      end
+
+      ##
+      # Retrieves the file with the given cache_name from the cache.
+      #
+      # === Parameters
+      #
+      # [cache_name (String)] uniquely identifies a cache file
+      #
+      # === Raises
+      #
+      # [CarrierWave::InvalidParameter] if the cache_name is incorrectly formatted.
+      #
+      def retrieve_from_cache!(cache_name)
+        with_callbacks(:retrieve_from_cache, cache_name) do
+          self.cache_id, self.original_filename = cache_name.to_s.split('/', 2)
+          @filename = original_filename
+          @file = CarrierWave::SanitizedFile.new(cache_path)
+        end
+      end
+
+    private
+
+      def cache_path
+        File.expand_path(File.join(cache_dir, cache_name), root)
+      end
+
+      attr_reader :cache_id, :original_filename
+
+      # We can override the full_original_filename method in other modules
+      alias_method :full_original_filename, :original_filename
+
+      def cache_id=(cache_id)
+        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}\z/
+        @cache_id = cache_id
+      end
+
+      def original_filename=(filename)
+        raise CarrierWave::InvalidParameter, "invalid filename" unless filename =~ /\A[a-z0-9\.\-\+_]+\z/i
+        @original_filename = filename
+      end
+
+    end # Cache
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/callbacks.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Callbacks
+
+      setup do
+        extlib_inheritable_accessor :_before_callbacks, :_after_callbacks
+      end
+
+      def with_callbacks(kind, *args)
+        self.class._before_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+        yield
+        self.class._after_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+      end
+
+      module ClassMethods
+        
+        def _before_callbacks_for(kind) #:nodoc:
+          self._before_callbacks ||= {}
+          self._before_callbacks[kind] ||= []
+          self._before_callbacks[kind]
+        end
+
+        def _after_callbacks_for(kind) #:nodoc:
+          self._after_callbacks ||= {}
+          self._after_callbacks[kind] ||= []
+          self._after_callbacks[kind]
+        end
+
+        def before(kind, callback)
+          _before_callbacks_for(kind) << callback
+        end
+
+        def after(kind, callback)
+          _after_callbacks_for(kind) << callback
+        end
+      end # ClassMethods
+
+    end # Callbacks
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/configuration.rb

@@ -0,0 +1,122 @@
+module CarrierWave
+
+  module Uploader
+    module Configuration
+      setup do
+        add_config :root
+        add_config :permissions
+        add_config :storage_engines
+        add_config :s3_access # for aws/s3
+        add_config :s3_access_policy # for right_aws
+        add_config :s3_bucket
+        add_config :s3_access_key_id
+        add_config :s3_secret_access_key
+        add_config :s3_cnamed
+        add_config :grid_fs_database
+        add_config :grid_fs_host
+        add_config :grid_fs_username
+        add_config :grid_fs_password
+        add_config :grid_fs_access_url
+        add_config :store_dir
+        add_config :cache_dir
+        add_config :enable_processing
+
+        # Mounting
+        add_config :ignore_integrity_errors
+        add_config :ignore_processing_errors
+        add_config :validate_integrity
+        add_config :validate_processing
+        add_config :mount_on
+        
+        configure do |config|
+          config.permissions = 0644
+          config.storage_engines = {
+            :file => "CarrierWave::Storage::File",
+            :s3 => "CarrierWave::Storage::S3",
+            :grid_fs => "CarrierWave::Storage::GridFS",
+            :right_s3 => "CarrierWave::Storage::RightS3"
+          }
+          config.storage = :file
+          config.s3_access = :public_read
+          config.s3_access_policy = 'public-read'
+          config.grid_fs_database = 'carrierwave'
+          config.grid_fs_host = 'localhost'
+          config.store_dir = 'uploads'
+          config.cache_dir = 'uploads/tmp'
+          config.ignore_integrity_errors = true
+          config.ignore_processing_errors = true
+          config.validate_integrity = true
+          config.validate_processing = true
+          config.root = CarrierWave.root
+          config.enable_processing = true
+        end
+      end
+
+      module ClassMethods
+
+        ##
+        # Sets the storage engine to be used when storing files with this uploader.
+        # Can be any class that implements a #store!(CarrierWave::SanitizedFile) and a #retrieve!
+        # method. See lib/carrierwave/storage/file.rb for an example. Storage engines should
+        # be added to CarrierWave::Uploader::Base.storage_engines so they can be referred
+        # to by a symbol, which should be more convenient
+        #
+        # If no argument is given, it will simply return the currently used storage engine.
+        #
+        # === Parameters
+        #
+        # [storage (Symbol, Class)] The storage engine to use for this uploader
+        #
+        # === Returns
+        #
+        # [Class] the storage engine to be used with this uploader
+        #
+        # === Examples
+        #
+        #     storage :file
+        #     storage CarrierWave::Storage::File
+        #     storage MyCustomStorageEngine
+        #
+        def storage(storage = nil)
+          if storage.is_a?(Symbol)
+            @storage = eval(storage_engines[storage])
+          elsif storage
+            @storage = storage
+          elsif @storage.nil?
+            # Get the storage from the superclass if there is one
+            @storage = superclass.storage rescue nil
+          end
+          return @storage
+        end
+        alias_method :storage=, :storage
+
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(value=nil)
+              @#{name} = value if value
+              return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+              name = superclass.#{name}
+              return nil if name.nil? && !instance_variable_defined?("@#{name}")
+              @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+            end
+
+            def self.#{name}=(value)
+              @#{name} = value
+            end
+
+            def #{name}
+              self.class.#{name}
+            end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+      end
+
+    end
+  end
+end
+

data/lib/carrierwave/uploader/default_url.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module DefaultUrl
+
+      def url(*args)
+        super || default_url
+      end
+
+      ##
+      # Override this method in your uploader to provide a default url
+      # in case no file has been cached/stored yet.
+      #
+      def default_url; end
+
+    end # DefaultPath
+  end # Uploader
+end # CarrierWave