paperclip_jk 5.0.0.beta2

data/lib/paperclip/matchers/validate_attachment_content_type_matcher.rb

@@ -0,0 +1,100 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the content type of
+      # the given attachment as specified.
+      #
+      # Example:
+      #   describe User do
+      #     it { should validate_attachment_content_type(:icon).
+      #                   allowing('image/png', 'image/gif').
+      #                   rejecting('text/plain', 'text/xml') }
+      #   end
+      def validate_attachment_content_type name
+        ValidateAttachmentContentTypeMatcher.new(name)
+      end
+
+      class ValidateAttachmentContentTypeMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+          @allowed_types = []
+          @rejected_types = []
+        end
+
+        def allowing *types
+          @allowed_types = types.flatten
+          self
+        end
+
+        def rejecting *types
+          @rejected_types = types.flatten
+          self
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.new if @subject.class == Class
+          @allowed_types && @rejected_types &&
+          allowed_types_allowed? && rejected_types_rejected?
+        end
+
+        def failure_message
+          "#{expected_attachment}\n".tap do |message|
+            message << accepted_types_and_failures.to_s
+            message << "\n\n" if @allowed_types.present? && @rejected_types.present?
+            message << rejected_types_and_failures.to_s
+          end
+        end
+
+        def description
+          "validate the content types allowed on attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def accepted_types_and_failures
+          if @allowed_types.present?
+            "Accept content types: #{@allowed_types.join(", ")}\n".tap do |message|
+              if @missing_allowed_types.present?
+                message << "  #{@missing_allowed_types.join(", ")} were rejected."
+              else
+                message << "  All were accepted successfully."
+              end
+            end
+          end
+        end
+        def rejected_types_and_failures
+          if @rejected_types.present?
+            "Reject content types: #{@rejected_types.join(", ")}\n".tap do |message|
+              if @missing_rejected_types.present?
+                message << "  #{@missing_rejected_types.join(", ")} were accepted."
+              else
+                message << "  All were rejected successfully."
+              end
+            end
+          end
+        end
+
+        def expected_attachment
+          "Expected #{@attachment_name}:\n"
+        end
+
+        def type_allowed?(type)
+          @subject.send("#{@attachment_name}_content_type=", type)
+          @subject.valid?
+          @subject.errors[:"#{@attachment_name}_content_type"].blank?
+        end
+
+        def allowed_types_allowed?
+          @missing_allowed_types ||= @allowed_types.reject { |type| type_allowed?(type) }
+          @missing_allowed_types.none?
+        end
+
+        def rejected_types_rejected?
+          @missing_rejected_types ||= @rejected_types.select { |type| type_allowed?(type) }
+          @missing_rejected_types.none?
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers/validate_attachment_presence_matcher.rb

@@ -0,0 +1,59 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the presence of the
+      # given attachment.
+      #
+      # describe User do
+      #   it { should validate_attachment_presence(:avatar) }
+      # end
+      def validate_attachment_presence name
+        ValidateAttachmentPresenceMatcher.new(name)
+      end
+
+      class ValidateAttachmentPresenceMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = subject.new if subject.class == Class
+          error_when_not_valid? && no_error_when_valid?
+        end
+
+        def failure_message
+          "Attachment #{@attachment_name} should be required"
+        end
+
+        def failure_message_when_negated
+          "Attachment #{@attachment_name} should not be required"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "require presence of attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def error_when_not_valid?
+          @subject.send(@attachment_name).assign(nil)
+          @subject.valid?
+          @subject.errors[:"#{@attachment_name}"].present?
+        end
+
+        def no_error_when_valid?
+          @file = StringIO.new(".")
+          @subject.send(@attachment_name).assign(@file)
+          @subject.valid?
+          expected_message = [
+            @attachment_name.to_s.titleize,
+            I18n.t(:blank, scope: [:errors, :messages])
+          ].join(' ')
+          @subject.errors.full_messages.exclude?(expected_message)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers/validate_attachment_size_matcher.rb

@@ -0,0 +1,96 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the size of the
+      # given attachment as specified.
+      #
+      # Examples:
+      #   it { should validate_attachment_size(:avatar).
+      #                 less_than(2.megabytes) }
+      #   it { should validate_attachment_size(:icon).
+      #                 greater_than(1024) }
+      #   it { should validate_attachment_size(:icon).
+      #                 in(0..100) }
+      def validate_attachment_size name
+        ValidateAttachmentSizeMatcher.new(name)
+      end
+
+      class ValidateAttachmentSizeMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def less_than size
+          @high = size
+          self
+        end
+
+        def greater_than size
+          @low = size
+          self
+        end
+
+        def in range
+          @low, @high = range.first, range.last
+          self
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.new if @subject.class == Class
+          lower_than_low? && higher_than_low? && lower_than_high? && higher_than_high?
+        end
+
+        def failure_message
+          "Attachment #{@attachment_name} must be between #{@low} and #{@high} bytes"
+        end
+
+        def failure_message_when_negated
+          "Attachment #{@attachment_name} cannot be between #{@low} and #{@high} bytes"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "validate the size of attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def override_method object, method, &replacement
+          (class << object; self; end).class_eval do
+            define_method(method, &replacement)
+          end
+        end
+
+        def passes_validation_with_size(new_size)
+          file = StringIO.new(".")
+          override_method(file, :size){ new_size }
+          override_method(file, :to_tempfile){ file }
+
+          @subject.send(@attachment_name).post_processing = false
+          @subject.send(@attachment_name).assign(file)
+          @subject.valid?
+          @subject.errors[:"#{@attachment_name}_file_size"].blank?
+        ensure
+          @subject.send(@attachment_name).post_processing = true
+        end
+
+        def lower_than_low?
+          @low.nil? || !passes_validation_with_size(@low - 1)
+        end
+
+        def higher_than_low?
+          @low.nil? || passes_validation_with_size(@low + 1)
+        end
+
+        def lower_than_high?
+          @high.nil? || @high == Float::INFINITY || passes_validation_with_size(@high - 1)
+        end
+
+        def higher_than_high?
+          @high.nil? || @high == Float::INFINITY || !passes_validation_with_size(@high + 1)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/media_type_spoof_detector.rb

@@ -0,0 +1,89 @@
+module Paperclip
+  class MediaTypeSpoofDetector
+    def self.using(file, name, content_type)
+      new(file, name, content_type)
+    end
+
+    def initialize(file, name, content_type)
+      @file = file
+      @name = name
+      @content_type = content_type || ""
+    end
+
+    def spoofed?
+      if has_name? && has_extension? && media_type_mismatch? && mapping_override_mismatch?
+        Paperclip.log("Content Type Spoof: Filename #{File.basename(@name)} (#{supplied_content_type} from Headers, #{content_types_from_name.map(&:to_s)} from Extension), content type discovered from file command: #{calculated_content_type}. See documentation to allow this combination.")
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def has_name?
+      @name.present?
+    end
+
+    def has_extension?
+      File.extname(@name).present?
+    end
+
+    def media_type_mismatch?
+      supplied_type_mismatch? || calculated_type_mismatch?
+    end
+
+    def supplied_type_mismatch?
+      supplied_media_type.present? && !media_types_from_name.include?(supplied_media_type)
+    end
+
+    def calculated_type_mismatch?
+      !media_types_from_name.include?(calculated_media_type)
+    end
+
+    def mapping_override_mismatch?
+      !Array(mapped_content_type).include?(calculated_content_type)
+    end
+
+
+    def supplied_content_type
+      @content_type
+    end
+
+    def supplied_media_type
+      @content_type.split("/").first
+    end
+
+    def content_types_from_name
+      @content_types_from_name ||= MIME::Types.type_for(@name)
+    end
+
+    def media_types_from_name
+      @media_types_from_name ||= content_types_from_name.collect(&:media_type)
+    end
+
+    def calculated_content_type
+      @calculated_content_type ||= type_from_file_command.chomp
+    end
+
+    def calculated_media_type
+      @calculated_media_type ||= calculated_content_type.split("/").first
+    end
+
+    def type_from_file_command
+      begin
+        Paperclip.run("file", "-b --mime :file", :file => @file.path).split(/[:;]\s+/).first
+      rescue Cocaine::CommandLineError
+        ""
+      end
+    end
+
+    def mapped_content_type
+      Paperclip.options[:content_type_mappings][filename_extension]
+    end
+
+    def filename_extension
+      File.extname(@name.to_s.downcase).sub(/^\./, '').to_sym
+    end
+  end
+end

data/lib/paperclip/missing_attachment_styles.rb

@@ -0,0 +1,79 @@
+require 'paperclip/attachment_registry'
+require 'set'
+
+module Paperclip
+  class << self
+    attr_writer :registered_attachments_styles_path
+    def registered_attachments_styles_path
+      @registered_attachments_styles_path ||= Rails.root.join('public/system/paperclip_attachments.yml').to_s
+    end
+  end
+
+  # Get list of styles saved on previous deploy (running rake paperclip:refresh:missing_styles)
+  def self.get_registered_attachments_styles
+    YAML.load_file(Paperclip.registered_attachments_styles_path)
+  rescue Errno::ENOENT
+    nil
+  end
+  private_class_method :get_registered_attachments_styles
+
+  def self.save_current_attachments_styles!
+    File.open(Paperclip.registered_attachments_styles_path, 'w') do |f|
+      YAML.dump(current_attachments_styles, f)
+    end
+  end
+
+  # Returns hash with styles for all classes using Paperclip.
+  # Unfortunately current version does not work with lambda styles:(
+  #   {
+  #     :User => {:avatar => [:small, :big]},
+  #     :Book => {
+  #       :cover => [:thumb, :croppable]},
+  #       :sample => [:thumb, :big]},
+  #     }
+  #   }
+  def self.current_attachments_styles
+    Hash.new.tap do |current_styles|
+      Paperclip::AttachmentRegistry.each_definition do |klass, attachment_name, attachment_attributes|
+        # TODO: is it even possible to take into account Procs?
+        next if attachment_attributes[:styles].kind_of?(Proc)
+        attachment_attributes[:styles].try(:keys).try(:each) do |style_name|
+          klass_sym = klass.to_s.to_sym
+          current_styles[klass_sym] ||= Hash.new
+          current_styles[klass_sym][attachment_name.to_sym] ||= Array.new
+          current_styles[klass_sym][attachment_name.to_sym] << style_name.to_sym
+          current_styles[klass_sym][attachment_name.to_sym].map!(&:to_s).sort!.map!(&:to_sym).uniq!
+        end
+      end
+    end
+  end
+  private_class_method :current_attachments_styles
+
+  # Returns hash with styles missing from recent run of rake paperclip:refresh:missing_styles
+  #   {
+  #     :User => {:avatar => [:big]},
+  #     :Book => {
+  #       :cover => [:croppable]},
+  #     }
+  #   }
+  def self.missing_attachments_styles
+    current_styles = current_attachments_styles
+    registered_styles = get_registered_attachments_styles
+
+    Hash.new.tap do |missing_styles|
+      current_styles.each do |klass, attachment_definitions|
+        attachment_definitions.each do |attachment_name, styles|
+          registered = registered_styles[klass][attachment_name] || [] rescue []
+          missed = styles - registered
+          if missed.present?
+            klass_sym = klass.to_s.to_sym
+            missing_styles[klass_sym] ||= Hash.new
+            missing_styles[klass_sym][attachment_name.to_sym] ||= Array.new
+            missing_styles[klass_sym][attachment_name.to_sym].concat(missed.to_a)
+            missing_styles[klass_sym][attachment_name.to_sym].map!(&:to_s).sort!.map!(&:to_sym).uniq!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/processor.rb

@@ -0,0 +1,48 @@
+module Paperclip
+  # Paperclip processors allow you to modify attached files when they are
+  # attached in any way you are able. Paperclip itself uses command-line
+  # programs for its included Thumbnail processor, but custom processors
+  # are not required to follow suit.
+  #
+  # Processors are required to be defined inside the Paperclip module and
+  # are also required to be a subclass of Paperclip::Processor. There is
+  # only one method you *must* implement to properly be a subclass:
+  # #make, but #initialize may also be of use. Both methods accept 3
+  # arguments: the file that will be operated on (which is an instance of
+  # File), a hash of options that were defined in has_attached_file's
+  # style hash, and the Paperclip::Attachment itself.
+  #
+  # All #make needs to return is an instance of File (Tempfile is
+  # acceptable) which contains the results of the processing.
+  #
+  # See Paperclip.run for more information about using command-line
+  # utilities from within Processors.
+  class Processor
+    attr_accessor :file, :options, :attachment
+
+    def initialize file, options = {}, attachment = nil
+      @file = file
+      @options = options
+      @attachment = attachment
+    end
+
+    def make
+    end
+
+    def self.make file, options = {}, attachment = nil
+      new(file, options, attachment).make
+    end
+
+    # The convert method runs the convert binary with the provided arguments.
+    # See Paperclip.run for the available options.
+    def convert(arguments = "", local_options = {})
+      Paperclip.run('convert', arguments, local_options)
+    end
+
+    # The identify method runs the identify binary with the provided arguments.
+    # See Paperclip.run for the available options.
+    def identify(arguments = "", local_options = {})
+      Paperclip.run('identify', arguments, local_options)
+    end
+  end
+end