card 1.19.0 → 1.19.1

data/vendor/carrierwave/lib/carrierwave/uploader/cache.rb

@@ -0,0 +1,207 @@
+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
+
+  class CacheCounter
+    @@counter = 0
+
+    def self.increment
+      @@counter += 1
+    end
+  end
+
+  ##
+  # Generates a unique cache id for use in the caching system
+  #
+  # === Returns
+  #
+  # [String] a cache id in the format TIMEINT-PID-COUNTER-RND
+  #
+  def self.generate_cache_id
+    [Time.now.utc.to_i,
+      Process.pid,
+      '%04d' % (CarrierWave::CacheCounter.increment % 1000),
+      '%04d' % rand(9999)
+    ].map(&:to_s).join('-')
+  end
+
+  module Uploader
+    module Cache
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+      include 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 keep cache files in one place only.
+        #
+        def clean_cached_files!(seconds=60*60*24)
+          cache_storage.new(CarrierWave::Uploader::Base.new).clean_cache!(seconds)
+        end
+      end
+
+      ##
+      # Returns true if the uploader has been cached
+      #
+      # === Returns
+      #
+      # [Bool] whether the current file is cached
+      #
+      def cached?
+        @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!
+        cache!
+      end
+
+      def sanitized_file
+        _content = file.read
+        if _content.is_a?(File) # could be if storage is Fog
+          sanitized = CarrierWave::Storage::Fog.new(self).retrieve!(File.basename(_content.path))
+        else
+          sanitized = SanitizedFile.new :tempfile => StringIO.new(_content),
+            :filename => File.basename(path), :content_type => file.content_type
+        end
+        sanitized
+      end
+
+      ##
+      # Returns a String which uniquely identifies the currently cached file for later retrieval
+      #
+      # === Returns
+      #
+      # [String] a cache name, in the format TIMEINT-PID-COUNTER-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.
+      #
+      # By default, cache!() uses copy_to(), which operates by copying the file
+      # to the cache, then deleting the original file.  If move_to_cache() is
+      # overriden to return true, then cache!() uses move_to(), which simply
+      # moves the file to the cache.  Useful for large files.
+      #
+      # === 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 = sanitized_file)
+        new_file = CarrierWave::SanitizedFile.new(new_file)
+        return if new_file.empty?
+
+        raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
+
+        self.cache_id = CarrierWave.generate_cache_id unless cache_id
+
+        @filename = new_file.filename
+        self.original_filename = new_file.filename
+
+        begin
+          # first, create a workfile on which we perform processings
+          if move_to_cache
+            @file = new_file.move_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          else
+            @file = new_file.copy_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          end
+
+          with_callbacks(:cache, @file) do
+            @file = cache_storage.cache!(@file)
+          end
+        ensure
+          FileUtils.rm_rf(workfile_path(''))
+        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 = cache_storage.retrieve_from_cache!(full_filename(original_filename))
+        end
+      end
+
+      ##
+      # Calculates the path where the cache file should be stored.
+      #
+      # === Parameters
+      #
+      # [for_file (String)] name of the file <optional>
+      #
+      # === Returns
+      #
+      # [String] the cache path
+      #
+      def cache_path(for_file=full_filename(original_filename))
+        File.join(*[cache_dir, @cache_id, for_file].compact)
+      end
+
+    private
+
+      def workfile_path(for_file=original_filename)
+        File.join(CarrierWave.tmp_path, @cache_id, version_name.to_s, for_file)
+      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)
+        # Earlier version used 3 part cache_id. Thus we should allow for
+        # the cache_id to have both 3 part and 4 part formats.
+        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]+\-[\d]+(\-[\d]{4})?\-[\d]{4}\z/
+        @cache_id = cache_id
+      end
+
+      def original_filename=(filename)
+        raise CarrierWave::InvalidParameter, "invalid filename" if filename =~ CarrierWave::SanitizedFile.sanitize_regexp
+        @original_filename = filename
+      end
+
+      def cache_storage
+        @cache_storage ||= self.class.cache_storage.new(self)
+      end
+    end # Cache
+  end # Uploader
+end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/uploader/callbacks.rb

@@ -0,0 +1,33 @@
+module CarrierWave
+  module Uploader
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        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[kind].each { |c| send c, *args }
+        yield
+        self.class._after_callbacks[kind].each { |c| send c, *args }
+      end
+
+      module ClassMethods
+        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.
+            merge kind => _after_callbacks[kind] + [callback]
+        end
+      end # ClassMethods
+
+    end # Callbacks
+  end # Uploader
+end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/uploader/configuration.rb

@@ -0,0 +1,203 @@
+module CarrierWave
+
+  module Uploader
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_storage, :_cache_storage, :instance_writer => false
+
+        add_config :root
+        add_config :base_path
+        add_config :asset_host
+        add_config :permissions
+        add_config :directory_permissions
+        add_config :storage_engines
+        add_config :store_dir
+        add_config :cache_dir
+        add_config :enable_processing
+        add_config :ensure_multipart_form
+        add_config :delete_tmp_file_after_storage
+        add_config :move_to_cache
+        add_config :move_to_store
+        add_config :remove_previously_stored_files_after_update
+
+        # fog
+        add_config :fog_provider
+        add_config :fog_attributes
+        add_config :fog_credentials
+        add_config :fog_directory
+        add_config :fog_public
+        add_config :fog_authenticated_url_expiration
+        add_config :fog_use_ssl_for_aws
+
+        # Mounting
+        add_config :ignore_integrity_errors
+        add_config :ignore_processing_errors
+        add_config :ignore_download_errors
+        add_config :validate_integrity
+        add_config :validate_processing
+        add_config :validate_download
+        add_config :mount_on
+        add_config :cache_only
+
+        # set default values
+        reset_config
+      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)
+          case storage
+          when Symbol
+            if storage_engine = storage_engines[storage]
+              self._storage = eval storage_engine
+            else
+              raise CarrierWave::UnknownStorageError, "Unknown storage: #{storage}"
+            end
+          when nil
+            storage
+          else
+            self._storage = storage
+          end
+          _storage
+        end
+        alias_method :storage=, :storage
+
+        ##
+        # Sets the cache storage engine to be used when storing cache files with this uploader.
+        # Same as .storage except for required methods being #cache!(CarrierWave::SanitizedFile),
+        # #retrieve_from_cache! and #delete_dir!.
+        #
+        # === Parameters
+        #
+        # [storage (Symbol, Class)] The cache storage engine to use for this uploader
+        #
+        # === Returns
+        #
+        # [Class] the cache storage engine to be used with this uploader
+        #
+        # === Examples
+        #
+        #     cache_storage :file
+        #     cache_storage CarrierWave::Storage::File
+        #     cache_storage MyCustomStorageEngine
+        #
+        def cache_storage(storage = nil)
+          if storage
+            self._cache_storage = storage.is_a?(Symbol) ? eval(storage_engines[storage]) : storage
+          end
+          _cache_storage
+        end
+        alias_method :cache_storage=, :cache_storage
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.eager_load_fog(fog_credentials)
+              # see #1198. This will hopefully no longer be necessary after fog 2.0
+              require self.fog_provider
+              require 'carrierwave/storage/fog'
+              Fog::Storage.new(fog_credentials) if fog_credentials.present?
+            end
+
+            def self.#{name}(value=nil)
+              @#{name} = value if value
+              eager_load_fog(value) if value && '#{name}' == 'fog_credentials'
+              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)
+              eager_load_fog(value) if '#{name}' == 'fog_credentials' && value.present?
+              @#{name} = value
+            end
+
+            def #{name}=(value)
+              self.class.eager_load_fog(value) if '#{name}' == 'fog_credentials' && value.present?
+              @#{name} = value
+            end
+
+            def #{name}
+              value = @#{name} if instance_variable_defined?(:@#{name})
+              value = self.class.#{name} unless instance_variable_defined?(:@#{name})
+              if value.instance_of?(Proc)
+                value.arity >= 1 ? value.call(self) : value.call
+              else
+                value
+              end
+            end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+
+        ##
+        # sets configuration back to default
+        #
+        def reset_config
+          configure do |config|
+            config.permissions = 0644
+            config.directory_permissions = 0755
+            config.storage_engines = {
+              :file => "CarrierWave::Storage::File",
+              :fog  => "CarrierWave::Storage::Fog"
+            }
+            config.storage = :file
+            config.cache_storage = :file
+            config.fog_provider = 'fog'
+            config.fog_attributes = {}
+            config.fog_credentials = {}
+            config.fog_public = true
+            config.fog_authenticated_url_expiration = 600
+            config.fog_use_ssl_for_aws = true
+            config.store_dir = 'uploads'
+            config.cache_dir = 'uploads/tmp'
+            config.delete_tmp_file_after_storage = true
+            config.move_to_cache = false
+            config.move_to_store = false
+            config.remove_previously_stored_files_after_update = true
+            config.ignore_integrity_errors = true
+            config.ignore_processing_errors = true
+            config.ignore_download_errors = true
+            config.validate_integrity = true
+            config.validate_processing = true
+            config.validate_download = true
+            config.root = lambda { CarrierWave.root }
+            config.base_path = CarrierWave.base_path
+            config.enable_processing = true
+            config.ensure_multipart_form = true
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/vendor/carrierwave/lib/carrierwave/uploader/content_type_blacklist.rb

@@ -0,0 +1,48 @@
+module CarrierWave
+  module Uploader
+    module ContentTypeBlacklist
+      extend ActiveSupport::Concern
+
+      included do
+        before :cache, :check_content_type_blacklist!
+      end
+
+      ##
+      # Override this method in your uploader to provide a blacklist of files content types
+      # which are not allowed to be uploaded.
+      # Not only strings but Regexp are allowed as well.
+      #
+      # === Returns
+      #
+      # [NilClass, String, Regexp, Array[String, Regexp]] a blacklist of content types which are not allowed to be uploaded
+      #
+      # === Examples
+      #
+      #     def content_type_blacklist
+      #       %w(text/json application/json)
+      #     end
+      #
+      # Basically the same, but using a Regexp:
+      #
+      #     def content_type_blacklist
+      #       [/(text|application)\/json/]
+      #     end
+      #
+      def content_type_blacklist; end
+
+    private
+
+      def check_content_type_blacklist!(new_file)
+        content_type = new_file.content_type
+        if content_type_blacklist && blacklisted_content_type?(content_type)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.content_type_blacklist_error", content_type: content_type)
+        end
+      end
+
+      def blacklisted_content_type?(content_type)
+        Array(content_type_blacklist).any? { |item| content_type =~ /#{item}/ }
+      end
+
+    end # ContentTypeBlacklist
+  end # Uploader
+end # CarrierWave