cloudfuji_paperclip 2.4.6 → 3.0.3

data/lib/paperclip/tempfile.rb

@@ -0,0 +1,41 @@
+module Paperclip
+  # Overriding some implementation of Tempfile
+  class Tempfile < ::Tempfile
+    # Due to how ImageMagick handles its image format conversion and how
+    # Tempfile handles its naming scheme, it is necessary to override how
+    # Tempfile makes # its names so as to allow for file extensions. Idea
+    # taken from the comments on this blog post:
+    # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+    #
+    # This is Ruby 1.8.7's implementation.
+    def make_tmpname(basename, n)
+      if RUBY_PLATFORM =~ /java/
+        case basename
+        when Array
+          prefix, suffix = *basename
+        else
+          prefix, suffix = basename, ''
+        end
+
+        t = Time.now.strftime("%y%m%d")
+        path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+      else
+        super
+      end
+    end
+  end
+
+  module TempfileEncoding
+    # This overrides Tempfile#binmode to make sure that the extenal encoding
+    # for binary mode is ASCII-8BIT. This behavior is what's in CRuby, but not
+    # in JRuby
+    def binmode
+      set_encoding('ASCII-8BIT')
+      super
+    end
+  end
+end
+
+if RUBY_PLATFORM =~ /java/
+  ::Tempfile.send :include, Paperclip::TempfileEncoding
+end

data/lib/paperclip/thumbnail.rb

@@ -44,7 +44,6 @@ module Paperclip
 
       @current_format      = File.extname(@file.path)
       @basename            = File.basename(@file.path, @current_format)
-
     end
 
     # Returns true if the +target_geometry+ is meant to crop.
@@ -76,9 +75,9 @@ module Paperclip
 
         success = Paperclip.run("convert", parameters, :source => "#{File.expand_path(src.path)}#{'[0]' unless animated?}", :dest => File.expand_path(dst.path))
       rescue Cocaine::ExitStatusError => e
-        raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
+        raise Paperclip::Error, "There was an error processing the thumbnail for #{@basename}" if @whiny
       rescue Cocaine::CommandNotFoundError => e
-        raise Paperclip::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
+        raise Paperclip::Errors::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
       end
 
       dst

data/lib/paperclip/validators.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+require 'paperclip/validators/attachment_content_type_validator'
+require 'paperclip/validators/attachment_presence_validator'
+require 'paperclip/validators/attachment_size_validator'
+
+module Paperclip
+  module Validators
+    extend ActiveSupport::Concern
+
+    included do
+      extend  HelperMethods
+      include HelperMethods
+    end
+
+    module ClassMethods
+      # This method is a shortcut to validator classes that is in
+      # "Attachment...Validator" format. It is almost the same thing as the
+      # +validates+ method that shipped with Rails, but this is customized to
+      # be using with attachment validators. This is helpful when you're using
+      # multiple attachment validators on a single attachment.
+      #
+      # Example of using the validator:
+      #
+      #   validates_attachment :avatar, :presence => true,
+      #      :content_type => { :content_type => "image/jpg" },
+      #      :size => { :in => 0..10.kilobytes }
+      #
+      def validates_attachment(*attributes)
+        options = attributes.extract_options!.dup
+
+        Paperclip::Validators.constants.each do |constant|
+          if constant.to_s =~ /^Attachment(.+)Validator$/
+            validator_kind = $1.underscore.to_sym
+
+            if options.has_key?(validator_kind)
+              options[:"attachment_#{validator_kind}"] = options.delete(validator_kind)
+            end
+          end
+        end
+
+        validates(*attributes + [options])
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_content_type_validator.rb

@@ -0,0 +1,54 @@
+module Paperclip
+  module Validators
+    class AttachmentContentTypeValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:allow_nil] = true unless options.has_key?(:allow_nil)
+        super
+      end
+
+      def validate_each(record, attribute, value)
+        attribute = "#{attribute}_content_type".to_sym
+        value = record.send(:read_attribute_for_validation, attribute)
+        allowed_types = [options[:content_type]].flatten
+
+        return if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+
+        if allowed_types.none? { |type| type === value }
+          record.errors.add(attribute, :invalid, options.merge(
+            :types => allowed_types.join(', ')
+          ))
+        end
+      end
+
+      def check_validity!
+        unless options.has_key?(:content_type)
+          raise ArgumentError, "You must pass in :content_type to the validator"
+        end
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveRecord-style 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.
+      # * +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)
+        validates_with AttachmentContentTypeValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_presence_validator.rb

@@ -0,0 +1,26 @@
+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
+        end
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveRecord-style 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)
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_size_validator.rb

@@ -0,0 +1,102 @@
+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]
+
+      def initialize(options)
+        extract_options(options)
+        super
+      end
+
+      def validate_each(record, attr_name, value)
+        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
+              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)
+              ))
+            end
+          end
+        end
+      end
+
+      def check_validity!
+        unless (AVAILABLE_CHECKS + [:in]).any? { |argument| options.has_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)
+        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+        unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => size.to_i, :raise => true)
+        storage_units_format.gsub(/%n/, size.to_i.to_s).gsub(/%u/, unit).html_safe
+      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 ActiveRecord-style 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)
+        validates_with AttachmentSizeValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/paperclip/version.rb

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

data/lib/tasks/paperclip.rake

@@ -10,7 +10,7 @@ module Paperclip
       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.include?(name)
+      if !name.blank? && klass.attachment_definitions.keys.map(&:to_s).include?(name.to_s)
         [ name ]
       else
         klass.attachment_definitions.keys
@@ -45,15 +45,11 @@ namespace :paperclip do
       names = Paperclip::Task.obtain_attachments(klass)
       names.each do |name|
         Paperclip.each_instance_with_attachment(klass, name) do |instance|
-          if file = instance.send(name).to_file(:original)
+          if file = Paperclip.io_adapters.for(instance.send(name))
             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")
-            if Rails.version >= "3.0.0"
-              instance.save(:validate => false)
-            else
-              instance.save(false)
-            end
+            instance.save(:validate => false)
           else
             true
           end
@@ -88,11 +84,7 @@ namespace :paperclip do
           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)
-            if Rails.version >= "3.0.0"
-              instance.save(:validate => false)
-            else
-              instance.save(false)
-            end
+            instance.save(:validate => false)
           end
         end
       end

data/paperclip.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |s|
   s.version           = Paperclip::VERSION
   s.platform          = Gem::Platform::RUBY
   s.author            = "Jon Yurek"
-  s.email             = ["sean@fakecoolguys.com"]
+  s.email             = ["sean@fakecoolguys.com", "jyurek@thoughtbot.com"]
   s.homepage          = "https://github.com/thoughtbot/paperclip"
   s.summary           = "File attachments as attributes for ActiveRecord"
-  s.description       = "Temporary fork of the paperclip gem to support AWS STS"
+  s.description       = "Easy upload management for ActiveRecord"
 
   s.rubyforge_project = "paperclip"
 
@@ -18,24 +18,34 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  if File.exists?('UPGRADING')
+    s.post_install_message = File.read("UPGRADING")
+  end
+
   s.requirements << "ImageMagick"
+  s.required_ruby_version = ">= 1.9.2"
 
-  s.add_dependency('activerecord', '>= 2.3.0')
-  s.add_dependency('activesupport', '>= 2.3.2')
+  s.add_dependency('activerecord', '>= 3.0.0')
+  s.add_dependency('activemodel', '>= 3.0.0')
+  s.add_dependency('activesupport', '>= 3.0.0')
   s.add_dependency('cocaine', '>= 0.0.2')
   s.add_dependency('mime-types')
 
   s.add_development_dependency('shoulda')
-  s.add_development_dependency('appraisal', '~> 0.4.0')
+  s.add_development_dependency('appraisal')
   s.add_development_dependency('mocha')
   s.add_development_dependency('aws-sdk')
+  s.add_development_dependency('bourne')
   s.add_development_dependency('sqlite3', '~> 1.3.4')
   s.add_development_dependency('cucumber', '~> 1.1.0')
   s.add_development_dependency('aruba')
+  s.add_development_dependency('nokogiri')
   s.add_development_dependency('capybara')
   s.add_development_dependency('bundler')
   s.add_development_dependency('cocaine', '~> 0.2')
   s.add_development_dependency('fog')
+  s.add_development_dependency('pry')
+  s.add_development_dependency('launchy')
   s.add_development_dependency('rake')
   s.add_development_dependency('fakeweb')
 end

data/test/adapter_registry_test.rb

@@ -0,0 +1,32 @@
+require './test/helper'
+
+class AdapterRegistryTest < Test::Unit::TestCase
+  context "for" do
+    setup do
+      class AdapterTest
+        def initialize(target); end
+      end
+      @subject = Paperclip::AdapterRegistry.new
+      @subject.register(AdapterTest){|t| Symbol === t }
+    end
+    should "return the class registered for the adapted type" do
+      assert_equal AdapterTest, @subject.for(:target).class
+    end
+  end
+
+  context "registered?" do
+    setup do
+      class AdapterTest
+        def initialize(target); end
+      end
+      @subject = Paperclip::AdapterRegistry.new
+      @subject.register(AdapterTest){|t| Symbol === t }
+    end
+    should "return true when the class of this adapter has been registered" do
+      assert @subject.registered?(AdapterTest.new(:target))
+    end
+    should "return false when the adapter has not been registered" do
+      assert ! @subject.registered?(Object)
+    end
+  end
+end

data/test/attachment_adapter_test.rb

@@ -0,0 +1,51 @@
+require './test/helper'
+
+class AttachmentAdapterTest < Test::Unit::TestCase
+  def setup
+    rebuild_model :path => "tmp/:class/:attachment/:style/:filename"
+    @attachment = Dummy.new.avatar
+    @file = File.new(fixture_file("5k.png"))
+    @file.binmode
+
+    @attachment.assign(@file)
+    @attachment.save
+    @subject = Paperclip.io_adapters.for(@attachment)
+  end
+
+  def teardown
+    @file.close
+  end
+
+  should "get the right filename" do
+    assert_equal "5k.png", @subject.original_filename
+  end
+
+  should "force binmode on tempfile" do
+    assert @subject.instance_variable_get("@tempfile").binmode?
+  end
+
+  should "get the content type" do
+    assert_equal "image/png", @subject.content_type
+  end
+
+  should "get the file's size" do
+    assert_equal 4456, @subject.size
+  end
+
+  should "return false for a call to nil?" do
+    assert ! @subject.nil?
+  end
+
+  should "generate a MD5 hash of the contents" do
+    expected = Digest::MD5.file(@file.path).to_s
+    assert_equal expected, @subject.fingerprint
+  end
+
+  should "read the contents of the file" do
+    expected = @file.read
+    actual = @subject.read
+    assert expected.length > 0
+    assert_equal expected.length, actual.length
+    assert_equal expected, actual
+  end
+end