paperclip 3.4.2 → 3.5.0

data/lib/paperclip/io_adapters/abstract_adapter.rb

@@ -23,6 +23,14 @@ module Paperclip
       @original_filename = new_filename.gsub(OS_RESTRICTED_CHARACTERS, "_")
     end
 
+    def nil?
+      false
+    end
+
+    def assignment?
+      true
+    end
+
     private
 
     def destination

data/lib/paperclip/io_adapters/data_uri_adapter.rb

@@ -0,0 +1,27 @@
+module Paperclip
+  class DataUriAdapter < StringioAdapter
+
+    REGEXP = /^data:([-\w]+\/[-\w\+]+);base64,(.*)/
+
+    def initialize(target_uri)
+      @target_uri = target_uri
+      cache_current_values
+      @tempfile = copy_to_tempfile
+    end
+
+    private
+
+    def cache_current_values
+      self.original_filename = 'base64.txt'
+      data_uri_parts ||= @target_uri.match(REGEXP) || []
+      @content_type = data_uri_parts[1] || 'text/plain'
+      @target = StringIO.new(Base64.decode64(data_uri_parts[2] || ''))
+      @size = @target.size
+    end
+
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::DataUriAdapter do |target|
+  String === target && target =~ Paperclip::DataUriAdapter::REGEXP
+end

data/lib/paperclip/io_adapters/empty_string_adapter.rb

@@ -0,0 +1,18 @@
+module Paperclip
+  class EmptyStringAdapter < AbstractAdapter
+    def initialize(target)
+    end
+
+    def nil?
+      false
+    end
+
+    def assignment?
+      false
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::EmptyStringAdapter do |target|
+  target.is_a?(String) && target.empty?
+end

data/lib/paperclip/io_adapters/stringio_adapter.rb

@@ -3,7 +3,7 @@ module Paperclip
     def initialize(target)
       @target = target
       cache_current_values
-      @tempfile = copy_to_tempfile(@target)
+      @tempfile = copy_to_tempfile
     end
 
     attr_writer :content_type
@@ -21,8 +21,8 @@ module Paperclip
       @size = @target.size
     end
 
-    def copy_to_tempfile(src)
-      while data = src.read(16*1024)
+    def copy_to_tempfile
+      while data = @target.read(16*1024)
         destination.write(data)
       end
       destination.rewind

data/lib/paperclip/matchers/have_attached_file_matcher.rb

@@ -20,7 +20,7 @@ module Paperclip
         def matches? subject
           @subject = subject
           @subject = @subject.class unless Class === @subject
-          responds? && has_column? && included?
+          responds? && has_column?
         end
 
         def failure_message
@@ -47,10 +47,6 @@ module Paperclip
         def has_column?
           @subject.column_names.include?("#{@attachment_name}_file_name")
         end
-
-        def included?
-          @subject.ancestors.include?(Paperclip::InstanceMethods)
-        end
       end
     end
   end

data/lib/paperclip/missing_attachment_styles.rb

@@ -1,16 +1,14 @@
-
+require 'paperclip/tasks/attachments'
 require 'set'
+
 module Paperclip
   class << self
-    attr_accessor :classes_with_attachments
     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
 
-  self.classes_with_attachments = Set.new
-
   # 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)
@@ -36,18 +34,15 @@ module Paperclip
   #   }
   def self.current_attachments_styles
     Hash.new.tap do |current_styles|
-      Paperclip.classes_with_attachments.each do |klass_name|
-        klass = Paperclip.class_for(klass_name)
-        klass.attachment_definitions.each do |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
+      Paperclip::Tasks::Attachments.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

data/lib/paperclip/storage/filesystem.rb

@@ -36,9 +36,13 @@ module Paperclip
       def flush_writes #:nodoc:
         @queued_for_write.each do |style_name, file|
           FileUtils.mkdir_p(File.dirname(path(style_name)))
-          File.open(path(style_name), "wb") do |new_file|
-            while chunk = file.read(16 * 1024)
-              new_file.write(chunk)
+          begin
+            FileUtils.mv(file.path, path(style_name))
+          rescue SystemCallError
+            File.open(path(style_name), "wb") do |new_file|
+              while chunk = file.read(16 * 1024)
+                new_file.write(chunk)
+              end
             end
           end
           unless @options[:override_file_permissions] == false

data/lib/paperclip/storage/s3.rb

@@ -164,6 +164,8 @@ module Paperclip
         if path
           base_options = { :expires => time, :secure => use_secure_protocol?(style_name) }
           s3_object(style_name).url_for(:read, base_options.merge(s3_url_options)).to_s
+        else
+          url
         end
       end
 

data/lib/paperclip/tasks/attachments.rb

@@ -0,0 +1,59 @@
+require 'singleton'
+
+module Paperclip
+  module Tasks
+    class Attachments
+      include Singleton
+
+      def self.add(klass, attachment_name, attachment_options)
+        instance.add(klass, attachment_name, attachment_options)
+      end
+
+      def self.clear
+        instance.clear
+      end
+
+      def self.names_for(klass)
+        instance.names_for(klass)
+      end
+
+      def self.each_definition(&block)
+        instance.each_definition(&block)
+      end
+
+      def self.definitions_for(klass)
+        instance.definitions_for(klass)
+      end
+
+      def initialize
+        clear
+      end
+
+      def add(klass, attachment_name, attachment_options)
+        @attachments ||= {}
+        @attachments[klass] ||= {}
+        @attachments[klass][attachment_name] = attachment_options
+      end
+
+      def clear
+        @attachments = Hash.new { |h,k| h[k] = {} }
+      end
+
+      def names_for(klass)
+        @attachments[klass].keys
+      end
+
+      def each_definition
+        @attachments.each do |klass, attachments|
+          attachments.each do |name, options|
+            yield klass, name, options
+          end
+        end
+      end
+
+      def definitions_for(klass)
+        @attachments[klass]
+      end
+    end
+  end
+end

data/lib/paperclip/validators.rb

@@ -34,13 +34,32 @@ module Paperclip
             validator_kind = $1.underscore.to_sym
 
             if options.has_key?(validator_kind)
-              options[:"attachment_#{validator_kind}"] = options.delete(validator_kind)
+              validator_options = options.delete(validator_kind)
+              validator_options = {} if validator_options == true
+              local_options = attributes + [validator_options]
+              send(:"validates_attachment_#{validator_kind}", *local_options)
             end
           end
         end
+      end
+
+      def validate_before_processing(validator_class, options)
+        options = options.dup
+        attributes = options.delete(:attributes)
+        attributes.each do |attribute|
+          options[:attributes] = [attribute]
+          create_validating_before_filter(attribute, validator_class, options)
+        end
+      end
 
-        validates(*attributes + [options])
+      def create_validating_before_filter(attribute, validator_class, options)
+        if_clause = options.delete(:if)
+        unless_clause = options.delete(:unless)
+        send(:"before_#{attribute}_post_process", :if => if_clause, :unless => unless_clause) do |*args|
+          validator_class.new(options.dup).validate(self)
+        end
       end
+
     end
   end
 end

data/lib/paperclip/validators/attachment_content_type_validator.rb

@@ -7,6 +7,7 @@ module Paperclip
       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
 
@@ -14,6 +15,10 @@ module Paperclip
 
         validate_whitelist(record, attribute, value)
         validate_blacklist(record, attribute, value)
+
+        if record.errors.include? attribute
+          record.errors.add base_attribute, record.errors[attribute]
+        end
       end
 
       def validate_whitelist(record, attribute, value)
@@ -48,7 +53,7 @@ module Paperclip
     end
 
     module HelperMethods
-      # Places ActiveRecord-style validations on the content type of the file
+      # 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
@@ -68,7 +73,9 @@ module Paperclip
       # 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)
-        validates_with AttachmentContentTypeValidator, _merge_attributes(attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentContentTypeValidator, options.dup
+        validate_before_processing AttachmentContentTypeValidator, options.dup
       end
     end
   end

data/lib/paperclip/validators/attachment_presence_validator.rb

@@ -2,24 +2,24 @@ require 'active_model/validations/presence'
 
 module Paperclip
   module Validators
-    class AttachmentPresenceValidator < ActiveModel::Validations::PresenceValidator
-      def validate(record)
-        [attributes].flatten.map do |attribute|
-          if record.send(:read_attribute_for_validation, "#{attribute}_file_name").blank?
-            record.errors.add(attribute, :blank, options)
-          end
+    class AttachmentPresenceValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if record.send("#{attribute}_file_name").blank?
+          record.errors.add(attribute, :blank, options)
         end
       end
     end
 
     module HelperMethods
-      # Places ActiveRecord-style validations on the presence of a file.
+      # 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)
-        validates_with AttachmentPresenceValidator, _merge_attributes(attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentPresenceValidator, options.dup
+        validate_before_processing AttachmentPresenceValidator, options.dup
       end
     end
   end

data/lib/paperclip/validators/attachment_size_validator.rb

@@ -11,6 +11,7 @@ module Paperclip
       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)
 
@@ -21,11 +22,13 @@ module Paperclip
 
             unless value.send(CHECKS[option], option_value)
               error_message_key = options[:in] ? :in_between : option
-              record.errors.add(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)
-              ))
+              [ 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
@@ -85,7 +88,7 @@ module Paperclip
     end
 
     module HelperMethods
-      # Places ActiveRecord-style validations on the size of the file assigned. The
+      # 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]
@@ -95,7 +98,9 @@ module Paperclip
       #   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)
-        validates_with AttachmentSizeValidator, _merge_attributes(attr_names)
+        options = _merge_attributes(attr_names)
+        validates_with AttachmentSizeValidator, options.dup
+        validate_before_processing AttachmentSizeValidator, options.dup
       end
     end
   end

data/lib/paperclip/version.rb

@@ -1,3 +1,3 @@
 module Paperclip
-  VERSION = "3.4.2" unless defined? Paperclip::VERSION
+  VERSION = "3.5.0" unless defined? Paperclip::VERSION
 end

data/lib/tasks/paperclip.rake

@@ -1,3 +1,5 @@
+require 'paperclip/tasks/attachments'
+
 module Paperclip
   module Task
     def self.obtain_class
@@ -9,13 +11,23 @@ module Paperclip
     def self.obtain_attachments(klass)
       klass = Paperclip.class_for(klass.to_s)
       name = ENV['ATTACHMENT'] || ENV['attachment']
-      raise "Class #{klass.name} has no attachments specified" unless klass.respond_to?(:attachment_definitions)
-      if !name.blank? && klass.attachment_definitions.keys.map(&:to_s).include?(name.to_s)
+
+      attachment_names = Paperclip::Tasks::Attachments.names_for(klass)
+
+      if attachment_names.empty?
+        raise "Class #{klass.name} has no attachments specified"
+      end
+
+      if !name.blank? && attachment_names.map(&:to_s).include?(name.to_s)
         [ name ]
       else
-        klass.attachment_definitions.keys
+        attachment_names
       end
     end
+
+    def self.log_error(error)
+      $stderr.puts error
+    end
   end
 end
 
@@ -31,10 +43,16 @@ namespace :paperclip do
       styles = (ENV['STYLES'] || ENV['styles'] || '').split(',').map(&:to_sym)
       names.each do |name|
         Paperclip.each_instance_with_attachment(klass, name) do |instance|
-          instance.send(name).reprocess!(*styles)
+          attachment = instance.send(name)
+          begin
+            attachment.reprocess!(*styles)
+          rescue Exception => e
+            Paperclip::Task.log_error("exception while processing #{klass} ID #{instance.id}:")
+            Paperclip::Task.log_error(" " + e.message + "\n")
+          end
           unless instance.errors.blank?
-            puts "errors while processing #{klass} ID #{instance.id}:"
-            puts " " + instance.errors.full_messages.join("\n ") + "\n"
+            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