card 1.19.3 → 1.19.4

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

@@ -1,207 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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