paperclip_jk 5.0.0.beta2

data/lib/paperclip/validators/attachment_file_type_ignorance_validator.rb

@@ -0,0 +1,29 @@
+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,30 @@
+require 'active_model/validations/presence'
+
+module Paperclip
+  module Validators
+    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
+
+      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]
+
+      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.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)
+        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,27 @@
+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
+      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 = "5.0.0.beta2" unless defined? Paperclip::VERSION
+end

data/lib/tasks/paperclip.rake

@@ -0,0 +1,127 @@
+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)
+
+      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
+        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 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?
+            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|
+          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")
+            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
+  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

data/paperclip.gemspec

@@ -0,0 +1,54 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require 'paperclip/version'
+
+Gem::Specification.new do |s|
+  s.name              = "paperclip_jk"
+  s.version           = Paperclip::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.author            = "Jon Yurek"
+  s.email             = ["jyurek@thoughtbot.com"]
+  s.homepage          = "https://github.com/thoughtbot/paperclip"
+  s.summary           = "File attachments as attributes for ActiveRecord"
+  s.description       = "Easy upload management for ActiveRecord"
+  s.license           = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  if File.exist?('UPGRADING')
+    s.post_install_message = File.read("UPGRADING")
+  end
+
+  s.requirements << "ImageMagick"
+  s.required_ruby_version = ">= 2.1.0"
+
+  s.add_dependency('activemodel', '>= 4.2.0')
+  s.add_dependency('activesupport', '>= 4.2.0')
+  s.add_dependency('cocaine', '~> 0.5.5')
+  s.add_dependency('mime-types')
+  s.add_dependency('mimemagic', '~> 0.3.0')
+
+  s.add_development_dependency('activerecord', '>= 4.2.0')
+  s.add_development_dependency('shoulda')
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('appraisal')
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('aws-sdk', '>= 2.0.34', '< 3.0')
+  s.add_development_dependency('bourne')
+  s.add_development_dependency('cucumber', '~> 1.3.18')
+  s.add_development_dependency('aruba', '~> 0.9.0')
+  s.add_development_dependency('nokogiri')
+  s.add_development_dependency('capybara')
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('fog-aws')
+  s.add_development_dependency('fog-local')
+  s.add_development_dependency('launchy')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('fakeweb')
+  s.add_development_dependency('railties')
+  s.add_development_dependency('actionmailer', '>= 4.2.0')
+  s.add_development_dependency('generator_spec')
+  s.add_development_dependency('timecop')
+end

data/shoulda_macros/paperclip.rb

@@ -0,0 +1,134 @@
+require 'paperclip/matchers'
+
+module Paperclip
+  # =Paperclip Shoulda Macros
+  #
+  # These macros are intended for use with shoulda, and will be included into
+  # your tests automatically. All of the macros use the standard shoulda
+  # assumption that the name of the test is based on the name of the model
+  # you're testing (that is, UserTest is the test for the User model), and
+  # will load that class for testing purposes.
+  module Shoulda
+    include Matchers
+    # This will test whether you have defined your attachment correctly by
+    # checking for all the required fields exist after the definition of the
+    # attachment.
+    def should_have_attached_file name
+      klass   = self.name.gsub(/Test$/, '').constantize
+      matcher = have_attached_file name
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests for validations on the presence of the attachment.
+    def should_validate_attachment_presence name
+      klass   = self.name.gsub(/Test$/, '').constantize
+      matcher = validate_attachment_presence name
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests that you have content_type validations specified. There are two
+    # options, :valid and :invalid. Both accept an array of strings. The
+    # strings should be a list of content types which will pass and fail
+    # validation, respectively.
+    def should_validate_attachment_content_type name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      valid   = [options[:valid]].flatten
+      invalid = [options[:invalid]].flatten
+      matcher = validate_attachment_content_type(name).allowing(valid).rejecting(invalid)
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests to ensure that you have file size validations turned on. You
+    # can pass the same options to this that you can to
+    # validate_attachment_file_size - :less_than, :greater_than, and :in.
+    # :less_than checks that a file is less than a certain size, :greater_than
+    # checks that a file is more than a certain size, and :in takes a Range or
+    # Array which specifies the lower and upper limits of the file size.
+    def should_validate_attachment_size name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+      max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+      range   = (min..max)
+      matcher = validate_attachment_size(name).in(range)
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Stubs the HTTP PUT for an attachment using S3 storage.
+    #
+    # @example
+    #   stub_paperclip_s3('user', 'avatar', 'png')
+    def stub_paperclip_s3(model, attachment, extension)
+      definition = model.gsub(" ", "_").classify.constantize.
+                         attachment_definitions[attachment.to_sym]
+
+      path = "http://s3.amazonaws.com/:id/#{definition[:path]}"
+      path.gsub!(/:([^\/\.]+)/) do |match|
+        "([^\/\.]+)"
+      end
+
+      begin
+        FakeWeb.register_uri(:put, Regexp.new(path), :body => "OK")
+      rescue NameError
+        raise NameError, "the stub_paperclip_s3 shoulda macro requires the fakeweb gem."
+      end
+    end
+
+    # Stub S3 and return a file for attachment. Best with Factory Girl.
+    # Uses a strict directory convention:
+    #
+    #     features/support/paperclip
+    #
+    # This method is used by the Paperclip-provided Cucumber step:
+    #
+    #     When I attach a "demo_tape" "mp3" file to a "band" on S3
+    #
+    # @example
+    #   Factory.define :band_with_demo_tape, :parent => :band do |band|
+    #     band.demo_tape { band.paperclip_fixture("band", "demo_tape", "png") }
+    #   end
+    def paperclip_fixture(model, attachment, extension)
+      stub_paperclip_s3(model, attachment, extension)
+      base_path = File.join(File.dirname(__FILE__), "..", "..",
+                            "features", "support", "paperclip")
+      File.new(File.join(base_path, model, "#{attachment}.#{extension}"))
+    end
+  end
+end
+
+if defined?(ActionDispatch::Integration::Session)
+  class ActionDispatch::IntegrationTest::Session  #:nodoc:
+    include Paperclip::Shoulda
+  end
+elsif defined?(ActionController::Integration::Session)
+  class ActionController::Integration::Session  #:nodoc:
+    include Paperclip::Shoulda
+  end
+end
+
+if defined?(FactoryGirl::Factory)
+  class FactoryGirl::Factory
+    include Paperclip::Shoulda  #:nodoc:
+  end
+else
+  class Factory
+    include Paperclip::Shoulda  #:nodoc:
+  end
+end
+
+if defined?(Minitest)
+  class Minitest::Unit::TestCase #:nodoc:
+    extend Paperclip::Shoulda
+  end
+elsif defined?(Test)
+  class Test::Unit::TestCase #:nodoc:
+    extend Paperclip::Shoulda
+  end
+end