kt-paperclip 6.2.0

data/lib/paperclip/validators/attachment_content_type_validator.rb

@@ -0,0 +1,88 @@
+module Paperclip
+  module Validators
+    class AttachmentContentTypeValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:allow_nil] = true unless options.key?(:allow_nil)
+        super
+      end
+
+      def self.helper_method_name
+        :validates_attachment_content_type
+      end
+
+      def validate_each(record, attribute, value)
+        base_attribute = attribute.to_sym
+        attribute = "#{attribute}_content_type".to_sym
+        value = record.send :read_attribute_for_validation, attribute
+
+        return if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+
+        validate_whitelist(record, attribute, value)
+        validate_blacklist(record, attribute, value)
+
+        if record.errors.include? attribute
+          record.errors[attribute].each do |error|
+            record.errors.add base_attribute, error
+          end
+        end
+      end
+
+      def validate_whitelist(record, attribute, value)
+        if allowed_types.present? && allowed_types.none? { |type| type === value }
+          mark_invalid record, attribute, allowed_types
+        end
+      end
+
+      def validate_blacklist(record, attribute, value)
+        if forbidden_types.present? && forbidden_types.any? { |type| type === value }
+          mark_invalid record, attribute, forbidden_types
+        end
+      end
+
+      def mark_invalid(record, attribute, types)
+        record.errors.add attribute, :invalid, options.merge(types: types.join(", "))
+      end
+
+      def allowed_types
+        [options[:content_type]].flatten.compact
+      end
+
+      def forbidden_types
+        [options[:not]].flatten.compact
+      end
+
+      def check_validity!
+        unless options.key?(:content_type) || options.key?(:not)
+          raise ArgumentError, "You must pass in either :content_type or :not to the validator"
+        end
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the content type of the file
+      # assigned. The possible options are:
+      # * +content_type+: Allowed content types.  Can be a single content type
+      #   or an array.  Each type can be a String or a Regexp. It should be
+      #   noted that Internet Explorer uploads files with content_types that you
+      #   may not expect. For example, JPEG images are given image/pjpeg and
+      #   PNGs are image/x-png, so keep that in mind when determining how you
+      #   match.  Allows all by default.
+      # * +not+: Forbidden content types.
+      # * +message+: The message to display when the uploaded file has an invalid
+      #   content type.
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run is this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      # NOTE: If you do not specify an [attachment]_content_type field on your
+      # model, content_type validation will work _ONLY upon assignment_ and
+      # re-validation after the instance has been reloaded will always succeed.
+      # You'll still need to have a virtual attribute (created by +attr_accessor+)
+      # name +[attachment]_content_type+ to be able to use this validator.
+      def validates_attachment_content_type(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentContentTypeValidator, options.dup
+        validate_before_processing AttachmentContentTypeValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_file_name_validator.rb

@@ -0,0 +1,75 @@
+module Paperclip
+  module Validators
+    class AttachmentFileNameValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:allow_nil] = true unless options.key?(:allow_nil)
+        super
+      end
+
+      def self.helper_method_name
+        :validates_attachment_file_name
+      end
+
+      def validate_each(record, attribute, value)
+        base_attribute = attribute.to_sym
+        attribute = "#{attribute}_file_name".to_sym
+        value = record.send :read_attribute_for_validation, attribute
+
+        return if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+
+        validate_whitelist(record, attribute, value)
+        validate_blacklist(record, attribute, value)
+
+        if record.errors.include? attribute
+          record.errors[attribute].each do |error|
+            record.errors.add base_attribute, error
+          end
+        end
+      end
+
+      def validate_whitelist(record, attribute, value)
+        mark_invalid record, attribute, allowed if allowed.present? && allowed.none? { |type| type === value }
+      end
+
+      def validate_blacklist(record, attribute, value)
+        mark_invalid record, attribute, forbidden if forbidden.present? && forbidden.any? { |type| type === value }
+      end
+
+      def mark_invalid(record, attribute, patterns)
+        record.errors.add attribute, :invalid, options.merge(names: patterns.join(", "))
+      end
+
+      def allowed
+        [options[:matches]].flatten.compact
+      end
+
+      def forbidden
+        [options[:not]].flatten.compact
+      end
+
+      def check_validity!
+        unless options.key?(:matches) || options.key?(:not)
+          raise ArgumentError, "You must pass in either :matches or :not to the validator"
+        end
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the name of the file
+      # assigned. The possible options are:
+      # * +matches+: Allowed filename patterns as Regexps. Can be a single one
+      #   or an array.
+      # * +not+: Forbidden file name patterns, specified the same was as +matches+.
+      # * +message+: The message to display when the uploaded file has an invalid
+      #   name.
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run is this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_attachment_file_name(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentFileNameValidator, options.dup
+        validate_before_processing AttachmentFileNameValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_file_type_ignorance_validator.rb

@@ -0,0 +1,28 @@
+require "active_model/validations/presence"
+
+module Paperclip
+  module Validators
+    class AttachmentFileTypeIgnoranceValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        # This doesn't do anything. It's just to mark that you don't care about
+        # the file_names or content_types of your incoming attachments.
+      end
+
+      def self.helper_method_name
+        :do_not_validate_attachment_file_type
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the presence of a file.
+      # Options:
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def do_not_validate_attachment_file_type(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentFileTypeIgnoranceValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_presence_validator.rb

@@ -0,0 +1,28 @@
+require "active_model/validations/presence"
+
+module Paperclip
+  module Validators
+    class AttachmentPresenceValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, _value)
+        record.errors.add(attribute, :blank, options) if record.send("#{attribute}_file_name").blank?
+      end
+
+      def self.helper_method_name
+        :validates_attachment_presence
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the presence of a file.
+      # Options:
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_attachment_presence(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentPresenceValidator, options.dup
+        validate_before_processing AttachmentPresenceValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_size_validator.rb

@@ -0,0 +1,109 @@
+require "active_model/validations/numericality"
+
+module Paperclip
+  module Validators
+    class AttachmentSizeValidator < ActiveModel::Validations::NumericalityValidator
+      AVAILABLE_CHECKS = [:less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to].freeze
+
+      def initialize(options)
+        extract_options(options)
+        super
+      end
+
+      def self.helper_method_name
+        :validates_attachment_size
+      end
+
+      def validate_each(record, attr_name, value)
+        base_attr_name = attr_name
+        attr_name = "#{attr_name}_file_size".to_sym
+        value = record.send(:read_attribute_for_validation, attr_name)
+
+        unless value.blank?
+          options.slice(*AVAILABLE_CHECKS).each do |option, option_value|
+            option_value = option_value.call(record) if option_value.is_a?(Proc)
+            option_value = extract_option_value(option, option_value)
+
+            unless value.send(CHECKS[option], option_value)
+              error_message_key = options[:in] ? :in_between : option
+              [attr_name, base_attr_name].each do |error_attr_name|
+                record.errors.add(error_attr_name, error_message_key, filtered_options(value).merge(
+                                                                        min: min_value_in_human_size(record),
+                                                                        max: max_value_in_human_size(record),
+                                                                        count: human_size(option_value)
+                                                                      ))
+              end
+            end
+          end
+        end
+      end
+
+      def check_validity!
+        unless (AVAILABLE_CHECKS + [:in]).any? { |argument| options.key?(argument) }
+          raise ArgumentError, "You must pass either :less_than, :greater_than, or :in to the validator"
+        end
+      end
+
+      private
+
+      def extract_options(options)
+        if range = options[:in]
+          if !options[:in].respond_to?(:call)
+            options[:less_than_or_equal_to] = range.max
+            options[:greater_than_or_equal_to] = range.min
+          else
+            options[:less_than_or_equal_to] = range
+            options[:greater_than_or_equal_to] = range
+          end
+        end
+      end
+
+      def extract_option_value(option, option_value)
+        if option_value.is_a?(Range)
+          if [:less_than, :less_than_or_equal_to].include?(option)
+            option_value.max
+          else
+            option_value.min
+          end
+        else
+          option_value
+        end
+      end
+
+      def human_size(size)
+        ActiveSupport::NumberHelper.number_to_human_size(size)
+      end
+
+      def min_value_in_human_size(record)
+        value = options[:greater_than_or_equal_to] || options[:greater_than]
+        value = value.call(record) if value.respond_to?(:call)
+        value = value.min if value.respond_to?(:min)
+        human_size(value)
+      end
+
+      def max_value_in_human_size(record)
+        value = options[:less_than_or_equal_to] || options[:less_than]
+        value = value.call(record) if value.respond_to?(:call)
+        value = value.max if value.respond_to?(:max)
+        human_size(value)
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the size of the file assigned. The
+      # possible options are:
+      # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
+      # * +less_than+: equivalent to :in => 0..options[:less_than]
+      # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
+      # * +message+: error message to display, use :min and :max as replacements
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_attachment_size(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentSizeValidator, options.dup
+        validate_before_processing AttachmentSizeValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/validators/media_type_spoof_detection_validator.rb

@@ -0,0 +1,29 @@
+require "active_model/validations/presence"
+
+module Paperclip
+  module Validators
+    class MediaTypeSpoofDetectionValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        adapter = Paperclip.io_adapters.for(value)
+        if Paperclip::MediaTypeSpoofDetector.using(adapter, value.original_filename, value.content_type).spoofed?
+          record.errors.add(attribute, :spoofed_media_type)
+        end
+
+        adapter.tempfile.close(true) if adapter.tempfile
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the presence of a file.
+      # Options:
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_media_type_spoof_detection(*attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with MediaTypeSpoofDetectionValidator, options.dup
+        validate_before_processing MediaTypeSpoofDetectionValidator, options.dup
+      end
+    end
+  end
+end

data/lib/paperclip/version.rb

@@ -0,0 +1,3 @@
+module Paperclip
+  VERSION = "6.2.0" unless defined?(Paperclip::VERSION)
+end

data/lib/tasks/paperclip.rake

@@ -0,0 +1,140 @@
+require "paperclip/attachment_registry"
+
+module Paperclip
+  module Task
+    def self.obtain_class
+      class_name = ENV["CLASS"] || ENV["class"]
+      raise "Must specify CLASS" unless class_name
+
+      class_name
+    end
+
+    def self.obtain_attachments(klass)
+      klass = Paperclip.class_for(klass.to_s)
+      name = ENV["ATTACHMENT"] || ENV["attachment"]
+
+      attachment_names = Paperclip::AttachmentRegistry.names_for(klass)
+
+      raise "Class #{klass.name} has no attachments specified" if attachment_names.empty?
+
+      if name.present? && attachment_names.map(&:to_s).include?(name.to_s)
+        [name]
+      else
+        attachment_names
+      end
+    end
+
+    def self.log_error(error)
+      $stderr.puts error
+    end
+  end
+end
+
+namespace :paperclip do
+  desc "Refreshes both metadata and thumbnails."
+  task refresh: ["paperclip:refresh:metadata", "paperclip:refresh:thumbnails"]
+
+  namespace :refresh do
+    desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT and STYLES splitted by comma)."
+    task thumbnails: :environment do
+      klass = Paperclip::Task.obtain_class
+      names = Paperclip::Task.obtain_attachments(klass)
+      styles = (ENV["STYLES"] || ENV["styles"] || "").split(",").map(&:to_sym)
+      names.each do |name|
+        Paperclip.each_instance_with_attachment(klass, name) do |instance|
+          attachment = instance.send(name)
+          begin
+            attachment.reprocess!(*styles)
+          rescue StandardError => e
+            Paperclip::Task.log_error("exception while processing #{klass} ID #{instance.id}:")
+            Paperclip::Task.log_error(" " + e.message + "\n")
+          end
+          unless instance.errors.blank?
+            Paperclip::Task.log_error("errors while processing #{klass} ID #{instance.id}:")
+            Paperclip::Task.log_error(" " + instance.errors.full_messages.join("\n ") + "\n")
+          end
+        end
+      end
+    end
+
+    desc "Regenerates content_type/size metadata for a given CLASS (and optional ATTACHMENT)."
+    task metadata: :environment do
+      klass = Paperclip::Task.obtain_class
+      names = Paperclip::Task.obtain_attachments(klass)
+      names.each do |name|
+        Paperclip.each_instance_with_attachment(klass, name) do |instance|
+          attachment = instance.send(name)
+          if file = Paperclip.io_adapters.for(attachment, attachment.options[:adapter_options])
+            instance.send("#{name}_file_name=", instance.send("#{name}_file_name").strip)
+            instance.send("#{name}_content_type=", file.content_type.to_s.strip)
+            instance.send("#{name}_file_size=", file.size) if instance.respond_to?("#{name}_file_size")
+            instance.save(validate: false)
+          else
+            true
+          end
+        end
+      end
+    end
+
+    desc "Regenerates missing thumbnail styles for all classes using Paperclip."
+    task missing_styles: :environment do
+      Rails.application.eager_load!
+      Paperclip.missing_attachments_styles.each do |klass, attachment_definitions|
+        attachment_definitions.each do |attachment_name, missing_styles|
+          puts "Regenerating #{klass} -> #{attachment_name} -> #{missing_styles.inspect}"
+          ENV["CLASS"] = klass.to_s
+          ENV["ATTACHMENT"] = attachment_name.to_s
+          ENV["STYLES"] = missing_styles.join(",")
+          Rake::Task["paperclip:refresh:thumbnails"].execute
+        end
+      end
+      Paperclip.save_current_attachments_styles!
+    end
+
+    desc "Regenerates fingerprints for a given CLASS (and optional ATTACHMENT). Useful when changing digest."
+    task fingerprints: :environment do
+      klass = Paperclip::Task.obtain_class
+      names = Paperclip::Task.obtain_attachments(klass)
+      names.each do |name|
+        Paperclip.each_instance_with_attachment(klass, name) do |instance|
+          attachment = instance.send(name)
+          attachment.assign(attachment)
+          instance.save(validate: false)
+        end
+      end
+    end
+  end
+
+  desc "Cleans out invalid attachments. Useful after you've added new validations."
+  task clean: :environment do
+    klass = Paperclip::Task.obtain_class
+    names = Paperclip::Task.obtain_attachments(klass)
+    names.each do |name|
+      Paperclip.each_instance_with_attachment(klass, name) do |instance|
+        unless instance.valid?
+          attributes = %w(file_size file_name content_type).map { |suffix| "#{name}_#{suffix}".to_sym }
+          if attributes.any? { |attribute| instance.errors[attribute].present? }
+            instance.send("#{name}=", nil)
+            instance.save(validate: false)
+          end
+        end
+      end
+    end
+  end
+
+  desc "find missing attachments. Useful to know which attachments are broken"
+  task find_broken_attachments: :environment do
+    klass = Paperclip::Task.obtain_class
+    names = Paperclip::Task.obtain_attachments(klass)
+    names.each do |name|
+      Paperclip.each_instance_with_attachment(klass, name) do |instance|
+        attachment = instance.send(name)
+        if attachment.exists?
+          print "."
+        else
+          Paperclip::Task.log_error("#{instance.class}##{attachment.name}, #{instance.id}, #{attachment.url}")
+        end
+      end
+    end
+  end
+end